Redis deletion policy and eviction policy

Knowledge points of this article

Expired data concept

Data deletion strategy

Eviction algorithm

Expired data

# Let’s first look at the three key values, namely sex, name, and age.

The instructions for setting these three values ​​are set name kaka setex age 100 24 setex sex 10 1

In redis we can use ttl to get the status of a certain key. Let’s use ttl to get the above information respectively. For the status of name, age, and sex

, you can see three values, which are -1 775 -2

So what is the information given by these three values!

• #-1 represents permanently valid data
• 775 This value is set on age, and the command used is setex age 1000 24, expressed as the remaining validity time
• -2 indicates expired data, or deleted data, or data that has no definition
  

Storage structure of expired data

• When we set a time-sensitive When the name is specified, redis stores a memory address 0x10101
• and then redis will open up another space to store the time-sensitive key
• , but the storage method is the memory address corresponding to the key and Expiration time
  
  #The redis deletion strategy we are talking about today is the deleted data.

Scheduled deletion

Scheduled deletion is to write a timer, and then when the key time expires, the timer task will immediately delete the expired key

Advantages: You can imagine that the key will be deleted when it expires. It is definitely the most memory-friendly and saves memory.

Disadvantages: The single-threaded feature of redis is that all commands are executed in a certain order. Deleting the key value when it expires will put more pressure on the CPU, which will directly affect the redis server response time and IO

Scheduled deletion means using time in exchange for space

After the scheduled deletion is completed, the data corresponding to the key value will be deleted, and the expired memory area will also be deleted directly.

Lazy deletion

Come and see This picture will not be deleted directly after the key value expires. When will it be deleted? Continue reading

When we use lazy deletion, the data will not be automatically deleted when it expires, so his deletion method is , the next time the key value is obtained, a judgment will be made to determine whether the key has expired. If it has expired, it will be deleted.

That is to say, when get name is executed again, a function will be executed expirelfNeeded() This function is to determine whether the key has expired. Return nil when expired, and then delete it from the memory

##Advantages: It will reduce a certain amount of CPU performance. It will only be deleted when it must be deleted

Disadvantage: It must be that the memory pressure is high, such as some hot news, after the hot spot is over, almost no one will access it. This key will always exist if no one accesses it, and it will occupy a certain amount of memory space for a long time

In other words, this method is to trade space for time

Delete regularly

We mentioned two deletion methods above, one is scheduled deletion and the other is lazy deletion. One is to trade space for time. One is to trade time for space. Both options are relatively extreme approaches. Then let's take a look at the implementation plan for regular deletion.

Let’s first take a look at the storage space of redis. There are 16 by default. There is a configuration parameter database in redis.conf that is controlled by this parameter. Each database has its own expiration partition, which stores data address and data expiration time.

Implementation method

redis is starting When, the value of hz under the server will be read, and the default is 10. This value can be viewed directly in the terminal using info server

Then the server will be executed hz times per second for serverCron() polling

Continue Use databasesCron to access the information of the 16 redis libraries one by one.

During the access, activeExpireCycel will be executed to detect each expires[*] one by one. The time of each execution is 250ms / server hz this parameter

When testing each expirs[*] one by one, ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC will be randomly picked out for testing

• If the key times out, delete the key directly
• The number of keys deleted in one round>ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC*25% continues to cycle the process
• If in one round The number of deleted keys <=ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC25%, check the next expires[]

##So now the problem comes, our 250ms / hz has been executed at this time, but what should I do if the 16 databases of expires have not been cycled through? Which library will I cycle next time? In fact, this value exists, it is the value of current_db. This value will record activeExpireCycel and execute it next time it enters expires[*]

Feature 1: No high peaks in CPU usage, custom setting of detection frequency

Feature 2: The memory pressure will not be very high, and the memory occupied for a long time will be continuously cleaned up

Eviction algorithm

We mentioned three deletion strategies above, but these three strategies are only effective relative to the key with a validity period set.

Now that our redis uses insufficient memory, we will use the eviction policy to ensure the normal use of redis.

Redis will call freeMemorylfNeeded() to check whether the memory is sufficient before each command is executed. When it is insufficient, some keys will be cleared. This data clearing strategy is called Eviction policy.

#The parameter of the maximum usable memory of redis is: maxmemory. The default is 0. It refers to the proportion of physical memory occupied. Generally, it is set to 50%.

Select the number of keys to be deleted each time: maxmemory-samples

Deletion policy: maxmemory-policy

Let’s focus on the deletion strategy

• Detect volatile data (that is, we set the validity period, but it has not expired yet The data is expires[*] above)

• volatile-lru: Select the recently used data
• volatile-lfu: Select the number of recent uses Minimal data
• volatile-ttl: Select the data to be eliminated
• volatile-random: Randomly select

Look at a picture next

• 9s is the current time
• The key with the longest distance from 9s is age
• The key with the least usage is gender
• If according to volatile- lru will delete age
• If you follow volatile-lfu, gender will be deleted
  
• Detect all data

• allkeys-lru: Select the data that has been used least recently
• allkeys-lfu: Select the data that has been used the least recently
• allkeys-random: Randomly use the entire database Delete

• Give up data eviction

• no-enviction: The data will not be deleted until the memory is used up. , causing an oom error.

Summary

The above is the deletion strategy and eviction strategy of redis for data.

One thing to note here is that in the eviction policy, volatile data refers to the key with an expiration time set, and is not a permanent value.

The whole database refers to all values, with expiration time and permanent data set.

The above is the detailed content of Redis deletion policy and eviction policy. For more information, please follow other related articles on the PHP Chinese website!