Redis usage and memory optimization

About Redis Installation configuration , You can refer to ： https://blog.csdn.net/weixin_46307478/article/details/122204294
About Python Use Redis, You can refer to ：https://blog.csdn.net/weixin_46307478/article/details/122953512

3、 ... and 、Redis Usage and memory optimization

redis In fact, the cost of memory management is very high , That is, it takes up too much memory , It belongs to trading space for time . The author is also very clear about this , Therefore, it provides a series of parameters and means to control and save memory

It is recommended not to turn on VM（ Virtual memory ） Options

VM Option is as Redis A persistence strategy that stores data that exceeds physical memory and is swapped in and out of memory and disk , It will seriously slow down the running speed of the system , So close VM function , Please check your redis.conf In file vm-enabled by no.

Set the maximum memory option

It is better to set redis.conf Medium maxmemory Options , This option is to tell Redis How much is used Physical memory Then it starts to reject subsequent write requests , This parameter can protect your Redis Will not be caused by using too much physical memory swap, Eventually, it will seriously affect the performance and even crash .

Generally, you also need to set the memory saturation recovery policy

1. volatile-lru： From the set of data for which the expiration time has been set （server.db[i].expires） Select the least recently used data in
2. volatile-ttl： From the set of data for which the expiration time has been set （server.db[i].expires） To select the data to be expired
3. volatile-random： From the set of data for which the expiration time has been set （server.db[i].expires） In the arbitrary selection of data elimination
4. allkeys-lru： From the data set （server.db[i].dict） Select the least recently used data in
5. allkeys-random： From the data set （server.db[i].dict） In the arbitrary selection of data elimination
6. no-enviction（ deportation ）： Exclusion data

Parameters that control memory usage

Redis A set of parameters is provided for different data types to control memory usage

1. Hash

redis.conf Below the configuration file 2 term

• **hash-max-zipmap-entries 64 **

The meaning is when value This Map When there are no more than a few internal members, it will be stored in a linear compact format , The default is 64, namely value Internal 64 Less than members use linear compact storage zipmap, If the value is exceeded, it will be automatically converted to real HashMap(ht).

• hash-max-zipmap-value 512

hash-max-zipmap-value The meaning is when value This Map The length of each internal member value does not exceed
How many bytes will use linear compact storage zipmap To save space .

above 2 Conditions any condition that exceeds the set value will be converted into a real HashMap, It will no longer save memory , But the bigger the better （ The space and the efficiency of checking and modifying need to be weighed according to the actual situation ）

1. List

• list-max-ziplist-entries 512
  list How many nodes of the data type are followed by a compact storage format with no pointer ziplist
• list-max-ziplist-value 64
  list Data type node values smaller than what bytes are stored in a compact format ziplist.

1. Set

• set-max-intset-entries 512
  set Data type internal data if all are numeric , And how many nodes are included below will be stored in compact format

Redis Internal optimization

1. Redis The internal implementation does not optimize the memory allocation too much , There will be memory fragmentation to some extent , But most of the time this won't be Redis Performance bottlenecks .
2. Redis Cache a certain range of Constant number Share as a resource , In many cases, numeric data types can greatly reduce memory overhead , The default is 1-10000, You can recompile the configuration to modify a line of macro definitions in the source code REDIS_SHARED_INTEGERS.

How to clean up memory fragments ？

restart Redis example :

• If Redis The data in is not persistent , that , The data is lost ;
• Even if Redis Data persistence , We still need to pass AOF or RDB Resume , The length of recovery depends on AOF or RDB Size , If only one Redis example , There is no service available in the recovery phase .

Fortunately, , from 4.0-RC3 After the version ,Redis It provides a method to clean up memory fragments automatically :

The basic mechanism :

• Memory fragmentation , Simply speaking , Namely “ Move to give way , Merge spaces ”.

Redis Parameters specially set for automatic memory fragment cleaning mechanism :

• Control the start and end time of debris cleaning
• The amount of CPU The proportion
• So as to reduce the impact of debris cleaning on Redis Performance impact of request processing itself

First ,Redis Automatic memory defragmentation needs to be enabled , You can put activedefrag Configuration item set to yes, The order is as follows ：

Conditions that trigger cleanup ( Need to meet at the same time ):

• active-defrag-ignore-bytes 100mb： The number of bytes representing memory fragmentation reaches 100MB when , Start cleaning ;
• active-defrag-threshold-lower 10： Represents the percentage of memory fragmentation allocated by the operating system to Redis The proportion of total space reached 10% when , Start cleaning .

In order to minimize debris cleaning on Redis The impact of normal request processing , When the automatic memory fragmentation function is executed , It will also monitor the occupancy of the cleaning operation CPU Time , And there are two parameters , They are used to control the occupation of CPU In proportion to time 、 Lower limit , Ensure that the cleaning work can be carried out normally , And avoid lowering Redis performance . These two parameters are as follows ：

• active-defrag-cycle-min 25： Represents the automatic cleaning process CPU The proportion of time is no less than 25%, Make sure the cleaning can be carried out normally ;
• active-defrag-cycle-max 75： Represents the automatic cleaning process CPU The proportion of time is not higher than 75%, Once you surpass , Just stop cleaning up , In order to avoid cleaning , A lot of memory copies are blocked Redis, This leads to an increase in response delay .