Introduction to the advantages, disadvantages and differences between redis and memcached

1. What are the benefits of using redis?

(1) It is fast because the data is stored in memory, similar to HashMap. The advantage of HashMap is that the time complexity of search and operation is O(1)

(2) Rich support Data type, supports string, list, set, sorted set, hash

(3) Supports transactions, operations are all atomic. The so-called atomicity means that all changes to the data are either executed or not executed at all

(4) Rich features: can be used for cache, messages, set expiration time by key, and will be automatically deleted after expiration

2. What are the advantages of redis compared to memcached?

(1) All values ​​in memcached are simple strings. As its replacement, redis supports richer data types

(2) Redis is much faster than memcached

(3) redis can persist its data

3. Common redis performance problems and solutions:

(1) Master is best not to do any persistence work, such as RDB memory snapshot and AOF log file

(2) If the data is important, a Slave enables AOF backup data, and the policy is set to synchronize once per second

(3) For master-slave replication For speed and connection stability, it is best for Master and Slave to be in the same LAN

(4) Try to avoid adding slave libraries to the master library that is under great pressure

(5) Master-Slave Do not use a graph structure for replication. It is more stable to use a one-way linked list structure, that is: Master

Such a structure is convenient to solve the problem of single point failure and realize Slave Replacement of Master. If the Master hangs up, you can immediately enable Slave1 as the Master, leaving everything else unchanged.

4. There are 20 million data in MySQL, but only 200,000 data are stored in redis. How to ensure that the data in redis are hot data

Related knowledge: The size of the redis memory data set has increased to a certain size When the time comes, a data elimination strategy will be implemented. redis provides 6 data elimination strategies:

voltile-lru: Select the least recently used data from the data set (server.db[i].expires) with an expiration time set to eliminate it

volatile-ttl: Select the data to be expired from the data set (server.db[i].expires) with an expiration time set for elimination

volatile-random: Select the data set with an expiration time (server. db[i].expires) to eliminate any data

allkeys-lru: Select the least recently used data from the data set (server.db[i].dict) to eliminate

allkeys -random: arbitrarily select data from the data set (server.db[i].dict) to eliminate

no-enviction (eviction): prohibit eviction of data

5. The difference between Memcache and Redis What are they?

1), Storage method

Memecache stores all data in the memory. It will hang up after power failure, and the data cannot exceed the memory size.

Redis is partially stored on the hard disk, which ensures data persistence.

2), Data support type

Memcache’s support for data types is relatively simple.

Redis has complex data types.

3). Different underlying models are used.

The underlying implementation methods and application protocols used to communicate with clients are different.

Redis directly builds the VM mechanism by itself, because if the general system calls system functions, it will waste a certain amount of time to move and request.

4), the value size

redis can reach a maximum of 1GB, while memcache is only 1MB

6. What are the common performance problems of Redis? How to solve?

1).Master writes memory snapshots, and the save command schedules the rdbSave function, which will block the work of the main thread. When the snapshot is relatively large, the impact on performance will be very large, and the service will be suspended intermittently, so Master is the best Do not write memory snapshots.

2). Master AOF persistence. If the AOF file is not rewritten, this persistence method will have the smallest impact on performance, but the AOF file will continue to grow. If the AOF file is too large, it will affect the recovery of the Master restart. speed.

Master is best not to do any persistence work, including memory snapshots and AOF log files. In particular, do not enable memory snapshots for persistence. If the data is critical, a Slave should enable AOF backup data. The strategy is to enable AOF backup data every time. Synchronize once every second.

3). Master calls BGREWRITEAOF to rewrite the AOF file. AOF will occupy a large amount of CPU and memory resources during rewriting, causing the service load to be too high and temporary service suspension.

4). Performance issues of Redis master-slave replication. For the speed of master-slave replication and the stability of the connection, it is best for Slave and Master to be in the same LAN.

7. Redis is most suitable Scenario

Redis is most suitable for all data in-momory scenarios. Although Redis also provides persistence function, it is actually more of a disk-backed function, which is quite different from persistence in the traditional sense. difference, then you may have questions. It seems that Redis is more like an enhanced version of Memcached, so when to use Memcached and when to use Redis?

If you simply compare the difference between Redis and Memcached, the big difference Most people will get the following opinions:

1. Redis not only supports simple k/v type data, but also provides storage of data structures such as list, set, zset, and hash.

2. Redis supports data backup, that is, data backup in master-slave mode.

3. Redis supports data persistence, which can keep data in memory on disk and can be loaded again for use when restarting.

(1) Session Cache

The most commonly used scenario for using Redis is session cache. The advantage of using Redis to cache sessions over other storage (such as Memcached) is that Redis provides persistence. When maintaining a cache that doesn't strictly require consistency, most people would be unhappy if all of the user's shopping cart information was lost. Now, would they still be?

Fortunately, as Redis has improved over the years, it is easy to find how to properly use Redis to cache session documents. Even the well-known commercial platform Magento provides Redis plug-ins.

(2), Full Page Cache (FPC)

In addition to the basic session token, Redis also provides a very simple FPC platform. Back to the consistency issue, even if the Redis instance is restarted, users will not see a decrease in page loading speed because of disk persistence. This is a great improvement, similar to PHP local FPC.

Taking Magento as an example again, Magento provides a plug-in to use Redis as a full-page cache backend.

In addition, for WordPress users, Pantheon has a very good plug-in wp-redis, which can help you load the pages you have browsed as quickly as possible.

(3) Queue

One of the great advantages of Redis in the field of memory storage engines is that it provides list and set operations, which allows Redis to be used as a good message queue platform. The operations used by Redis as a queue are similar to the push/pop operations of list in local programming languages ​​(such as Python).

If you quickly search "Redis queues" in Google, you will immediately find a large number of open source projects. The purpose of these projects is to use Redis to create very good back-end tools to meet various queue needs. . For example, Celery has a backend that uses Redis as a broker. You can view it from here.

(4), Ranking/Counter

Redis implements the operation of incrementing or decrementing numbers in memory very well. Sets and Sorted Sets also make it very simple for us to perform these operations. Redis just provides these two data structures.

So, we want to get the top 10 users from the sorted set – we call them “user_scores”, we just need to execute it like the following:

Of course , this assumes that you are sorting in ascending order based on your users' scores. If you want to return the user and the user's score, you need to execute it like this:

ZRANGE user_scores 0 10 WITHSCORES

Agora Games is a good example, implemented in Ruby, and its rankings use Redis to store data. You can See it here.

(5), Publish/Subscribe

Last (but certainly not least) is the publish/subscribe function of Redis. There are indeed many use cases for publish/subscribe. I've seen people use it in social network connections, as triggers for publish/subscribe based scripts, and even to build chat systems using Redis' publish/subscribe functionality! (No, this is true, you can check it out).

Of all the features provided by Redis, I feel that this is the one that people like the least, although it provides users with this multi-function.

For more redis knowledge, please pay attention to the redis introductory tutorial column.

The above is the detailed content of Introduction to the advantages, disadvantages and differences between redis and memcached. For more information, please follow other related articles on the PHP Chinese website!