Shulou(Shulou.com)06/01 Report--

This article mainly explains "what is the internal operation mechanism of redis". Interested friends may wish to take a look at it. The method introduced in this paper is simple, fast and practical. Next, let the editor take you to learn "what is the internal operation mechanism of redis"?

Redis is a database, but unlike the traditional database, the data of redis is stored in memory, so the read and write speed is very fast, so redis is widely used in the cache direction.

When the Redis server is initialized, redis.h/REDIS_DEFAULT_DBNUM (N) databases are created, and the id of the database is from 0 to Nmuri 1, and all databases are saved to the redis.h/redisServer.db array.

On the client side, you can switch through the "SELECT" command, where the program is switched directly with redis.h/redisServer.db [number]. However, some internal programs, such as AOF programs, replicators, and RDB programs, need to know the number of the current database. If there is no id field, the program can only compare the pointers of the currently used database with the pointers of all the databases in the redisServer.db array to find out which database they are using.

The structure of the Redis database: typeof struct redisDb {int id; / / the iddict * dict of the database; / / holds all the key-value pairs of the database, also known as the key space dict * expires; / / holds the expiration time of the key. .} redisDb; Redis is a key-value pair dictionary table. Similarly, the storage form of Redis database is also key-value pair dictionary table. Key values can be character type, list list, hash, collection and one of the ordered collections. Redis database adds, deletes, modifies, queries and other key space operations:

New: Redis adds a key-value pair to the key space dictionary, where the key is a string and the value is any value type. Delete: Redis will delete the key-value pair update of the corresponding key in the key space dictionary: Redis will release the value object of the corresponding key in the key space dictionary and let the key point to the new value object query: Redis will query the value object of the corresponding key in the key space dictionary: the key does not exist, returns the NULL key exists, and the type is correct, the correct value key exists, but the type is incorrect. Return type error other operations: in addition to the key value operations shown above, there are many commands for the database itself, which are also accomplished by dealing with the key space: FLUSHDB deletes all key value pairs in the key space RANDOMKEY randomly returns a key DBSIZE returns the number of key value pairs in the key space EXISTS checks whether the given key exists in the key space RENAME in the key space, renames the given key

The expiration time of the key

In the Redis database, the expiration time of all keys is saved in the expires dictionary of the RedisDb structure, where the key is a pointer to a key in the dict dictionary (key space), and the value is the modified expiration time, represented by the long long type.

Redis has four commands to set the key's survival time (how long it can survive) and expiration time (when it expires): EXPIRE sets the key's lifetime in seconds; PEXPIRE sets the key's lifetime in milliseconds; EXPIREAT sets the key's expiration UNIX timestamp in milliseconds; PEXPIREAT sets the key's expiration UNIX timestamp in milliseconds.

Although there are so many different units and different forms of setting, the value of the expires dictionary only holds the "expired UNIX timestamp in milliseconds," which means that with conversion, all commands end up having the same effect as the PEXPIREAT command.

Removal of expired keys

Scheduled cleanup: a scheduled task is created when the KEY is created. When the KEY expires, the timed task is triggered and the expired KEY is cleared the first time. This kind of operation is the most memory-friendly, and there is no garbage data taking up memory. The disadvantage is that it will cause a lot of server load, especially when the CPU load is high, a large part of the CPU load is used to delete unnecessary KEY.

Lazy removal: regardless of the keys in the key space, check whether the KEY expires every time you query the KEY, delete it if it expires, and return the corresponding VALUE normally if it does not expire. This operation is the most friendly to CPU, and this strategy is limited to the current KEY. The related unnecessary KEY will not cause the disadvantage of CPU load: it is easy to waste memory space, especially when there are a large number of expired KEY in the system and are rarely used, which greatly affects the performance of Redis that is very dependent on memory size.

Periodic deletion: the key scan of the timed script cron periodically scans the expires to determine whether there is an expired KEY, and if so, delete it. This is a compromise, which not only does not consume too much CPU, but also periodically clearly removes unnecessary memory consumption that is ignored.

Redis adopts a combination of "lazy cleanup" and "periodic clarity", in which the periodic delete mode is to traverse the expires dictionaries of each database as far as possible within the specified time limit, randomly check the expiration time of some keys, and delete the expired keys.

The pseudo code is as follows:

Def activeExpireCycle (): # traversing the database (not all can be traversed, see if there is enough time) for db in server.db:# MAX_KEY_PER_DB is the maximum number of key that a DB can handle # it ensures that time is not all spent on individual DB (avoid hunger) I # while (I # database is empty, jump out of while Process the next DB if db.is_empty (): break# randomly fetches a key with TTL key_with_ttl = db.expires.get_random_key () # check whether the key expires, if so, delete it if is_expired (key_with_ttl): db.deleteExpiredKey (key_with_ttl) # when the execution time reaches the upper limit, the function returns Do not continue # this ensures that the delete operation does not take up too much CPU time if reach_time_limit (): returni + = 1

Master-slave synchronization of Redis expired key deletion (the mechanism of Redis is uniformly controlled by the master node)

If the server is the master node, when it deletes an expired key, it will explicitly send a DEL command to all slave nodes. If the server is a slave node, when it determines that the current KEY has expired, it will send the key expired message to the master server. After the master server deletes, it sends a DEL command to all slave server nodes.

The key is deleted involuntarily from the slave node in order to maintain absolute consistency with the data of the master server, that is, when an expired key still exists on the master server, the key will not be deleted on all slave servers.

At this point, I believe you have a deeper understanding of "what is the internal operation mechanism of redis". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.