A comparison of Redis, Memcache, and MongoDB

1. Performance

are relatively high, performance is not a bottleneck for us

In general, the TPS is about the same as Redis and Memcache, more than MongoDB

2, the convenience of the operation

Memcache Data Structure Single

Redis is rich, data manipulation, Redis better, less network IO times

MongoDB supports rich data expression, index, most similar relational database, support query language is very rich

3. Size of memory space and amount of data

Redis has added its own VM features after the 2.0 release, breaking the limits of physical memory; You can set the expiration time for key value (similar to memcache)

Memcache can modify the maximum available memory, using the LRU algorithm

MongoDB is suitable for large data storage, depends on operating system VM to do memory management, eat memory is also very bad, service not with other services together

4. Availability (single point of issue)

For a single point of problem,

Redis, which relies on clients for distributed reads and writes, and master-slave replication relies on the entire snapshot every time the primary node is reconnected from the node, without incremental replication, due to performance and efficiency issues,

Therefore, the single point problem is more complicated, the automatic sharding is not supported, and the dependent program is required to set the consistent hash mechanism.

An alternative is to use your own proactive replication (multiple storage) instead of Redis's own replication mechanism, or change to incremental replication (you need to implement it yourself), consistency issues and performance tradeoffs

Memcache itself has no data redundancy mechanism, it is not necessary, for fault prevention, relying on mature hash or ring algorithm to solve the single point of failure caused by the jitter problem.

MongoDB supports Master-slave,replicaset (internal using Paxos election algorithm, automatic fault recovery), auto sharding mechanism, blocking the failover and segmentation mechanism to the client.

5. Reliability (persistent)

For data persistence and data recovery,

Redis Support (snapshot, AOF): dependent on snapshots for persistence, AOF enhances reliability while impacting performance

Memcache not supported, usually used in cache, improve performance;

MongoDB supports persistent reliability from the 1.8 release with the binlog approach

6. Data consistency (transactional support)

Memcache in concurrent scenarios, with CAS to ensure consistency

Redis transaction support is weak and can only guarantee continuous execution of each operation in a transaction

MongoDB does not support transactions

7. Data analysis

MongoDB has built-in data analysis capabilities (MapReduce), others do not support

8. Application Scenario

Redis: More performance operations and calculations with smaller data volumes

Memcache: Used to reduce database load in dynamic system, improve performance, cache, improve performance (suitable for read and write less, for a large amount of data, you can use sharding)

MongoDB: The main solution to the massive data access efficiency problem

Memcached

Advantages of memcached:
The memcached can take advantage of multicore advantages, with a very high single-instance throughput of hundreds of thousands of QPS (depending on key, the byte size of value, and server hardware performance, which is around 4-6w in the daily environment). Suitable for maximum carrying capacity.
Supports direct configuration for session handle.
Less pits.
Limitations of memcached:
Only simple KEY/VALUE data structures are supported, unlike Redis, which supports rich data types.
Cannot be persisted, data cannot be backed up, it can only be used for cache use, and data is lost after reboot.
Data synchronization cannot be performed and data in the MC cannot be migrated to another instance of MC.
Memcached memory allocation uses the slab allocation mechanism to manage memory, which causes memory utilization to decrease when the value size distribution is large, and causes problems such as kicking out when low utilization occurs. Users need to focus on value design.

Redis
Advantages of Redis:
Supports multiple data structures such as String (string), list (doubly linked list), Dict (hash table), set (set), Zset (sort set), Hyperloglog (cardinality estimation)
Support persistent operation, AOF and RDB data can be persisted to disk, so as to carry out data backup or data recovery operations, better prevent data loss means.
Support the data replication through replication, through the master-slave mechanism, can be in real-time synchronous replication of data, support multi-level replication and incremental replication, master-slave mechanism is an important means of Redis ha.
Single-threaded requests, all commands are executed serially, and there is no need to consider data consistency issues in the concurrency scenario.
Support PUB/SUB Message subscription mechanism, can be used for message subscription and notification.
Supports simple transaction requirements, but industry usage scenarios are rare and immature.

Limitations of Redis:
Redis can only use a single thread and performance is limited to CPU performance, so the single instance CPU can reach 5-6wqps per second (depending on data structure, data size and server hardware performance, and the QPS peak in daily environments is around 1-2w).
Support simple transaction requirements, but the industry use of the scene is very small, immature, both advantages and disadvantages.
Redis consumes more memory on string types, and can use Dict (hash table) to compress storage to reduce memory consumption.

:) Here is my personal supplement
Both MC and Redis are key-value types, are not suitable for establishing relationships between different datasets, and are not suitable for query search. For example, Redis's keyspattern , a matching operation, is a disaster for redis performance.

Mogodb
Mogodb is a document-type database. First explain the database of the document, that is, you can store XML, JSON, Bson type of data. These data are self-describing (self-describing), presenting hierarchical tree-like data structures. Redis can store simple relational data in hash.
MOGODB Store JSON-formatted data.
Suitable for scenarios: event logging, content management or blogging platforms, such as commenting systems.

NOSQ's products are currently many, the architect's choice of guidance mainly has the following two factors:
1) Suitable for the application of the use of the scene, such as the comment system is more appropriate to use MOGODB, and MC can also be implemented (the application to convert data into JSON, but some data update inconvenient)
2) The team develops familiar technologies, such as a team that has been using MC for a limited selection of MC rather than Redis.
In the middle of a serious situation, the development team has been using MOGODB to continue to select Mogodb in a scenario suitable for KV nosq.

A book recommended to you: <nosql essence >

Memcache and Redis are key-value storage systems, whereas Redis may be more adaptable than memcache, storing more value types, and Redis supports master-slave synchronization. And MONGO is a document-based database.
1. Memcache can be used primarily as a caching system for caching files, database query results, etc. because it reads in memory and improves the performance of Web services. can be used for Web site data caching, to reduce the direct query of the database, reduce stress.
2, Redis Of course can also be used as a cache, but you look at the Weibo, many scenarios are applications of Redis.
3, MongoDB is a document-based database. Its query speed is very fast, it is very suitable for real-time inserts, updates and queries, such as logging, message logging and so on.

Please refer to the following information:

Http://www.itnose.net/detail/6074493.html

A comparison of Redis, Memcache, and MongoDB