How to solve Redis buffer overflow

The buffer is a part of the memory space. In other words, a certain amount of storage space is reserved in the memory space. These storage spaces are used to buffer input or output data. This reserved space is called a buffer.

1. Impact of Redis buffer overflow

In Redis, there are three main scenarios that use the concept of buffer.

When communicating between the client and the server, it is used to temporarily store the command data sent by the client, or when the data results returned by the server to the client are synchronized between the master and slave nodes, Redis Use buffers to temporarily store write commands and data received by the master node. When Redis performs AOF persistence, Redis also uses the concept of buffers to avoid frequent disk writes.

The buffer concept was originally used by the operating system to ease The contradiction between the speed mismatch between CPU and I/O devices is introduced by improving the parallelism of CPU and I/O devices.

The mismatch between high-speed equipment and low-speed equipment will inevitably cause high-speed equipment to spend time waiting for low-speed equipment. The concept of buffer can solve this problem very well. The buffer is also an important embodiment of the producer-consumer model.

1. Buffer overflow causes network connection to close

If qubf-free is exhausted, it will cause client input buffer overflow, Redis processing The method is to close the client connection. The result is that the business program cannot access data.

2. Buffer overflow leads to command data loss or crash

Normally, there are many client connections. When the total memory occupied by client connections exceeds the maxmemory of Redis When configured, Redis will be triggered to perform data elimination, which will affect the access performance of business programs.

Even multiple clients can cause Redis to take up too much memory, and can also cause memory overflow problems, which can cause Redis to crash.

2. Client buffer

There are two more client buffers, the input buffer and the output buffer, both of which are designed to solve the problem of inconsistency in request sending and processing speeds between the client and the server. Matches what is set.

The input buffer temporarily stores commands sent by the client. There are two common reasons for overflow:

Write BigKey, such as Millions of hashes or aggregate data are written at one time, exceeding the size of the buffer. The server processes requests too slowly, causing blocking and being unable to process requests in a timely manner. As a result, requests sent by the client accumulate in the buffer. many.

The output buffer temporarily stores the data to be returned to the client by the Redis main thread.

This data includes simple and fixed-size OK responses (for example, executing the SET command) or error messages, as well as execution results that are not fixed in size and contain specific data (for example, executing the HGET command)

There are three common causes of output buffer overflow:

Returning a large number of BigKey results Executing some unreasonable commands Unreasonable buffer size settings

From input and output buffers Judging from the common causes of overflow, BigKey is the most likely cause of overflow, so we should try to avoid using BigKey.

For the input buffer, because there is no way to change its size (default 1G per client), we can only control the sending and processing speed of commands to avoid blocking as much as possible.

For the output buffer, avoid using some commands that return a large number of results, such as KEYS, MONITOR, etc. At the same time, you can avoid overflow by adjusting the size of the output buffer.

3. Copy buffer

The copy buffer is used for copying between Redis master and slave nodes. Because data replication between master and slave nodes includes full replication and incremental replication. Therefore, the copy buffer is also divided into two types: copy buffer and copy backlog buffer.

1. Copy buffer

During the full replication process, the master node will continue to receive write command requests sent by the client while transmitting RDB files to the slave node. These write commands will be saved in the replication buffer first, and will be sent to the slave node and executed after the RDB file transfer is completed. In order to ensure data synchronization between master and slave nodes, each slave node maintains a replication buffer on the master node.

For the replication buffer, if it takes a long time for the main library to transfer RDB files and load RDB files from the slave library, and at the same time, the main library receives a lot of write command operations, it will cause replication The buffer was filled and overflowed.

To avoid replication buffer overflow, on the one hand, we can control the amount of data saved by the master node, which can speed up the transmission of RDB files and the loading time of slave libraries to avoid excessive accumulation of replication buffers. Order.

You can also set the size of the replication buffer more reasonably to avoid overflow based on the data volume of the master node, the write load pressure of the master node, and the memory size of the master node itself to avoid overflow. In addition, since the master node will The node sets a replication buffer. If the number of slave nodes in the cluster is very large, the memory overhead of the master node will be very large, so we should try to avoid a master node having too many slave nodes.

2. Replication backlog buffer

During the incremental replication process, when the master node and the slave node perform regular synchronization, the write command will be temporarily stored in the replication buffer. If a network disconnection occurs between the slave node and the master node, command operations that have not yet been replicated can be synchronized from the replication backlog buffer after the slave node is reconnected.

It should be noted that the copy backlog buffer is a ring buffer with a limited size.

When the master node fills up the replication backlog buffer, it will overwrite the old command data in the buffer. At this time, the data of the master and slave nodes will be inconsistent.

To address this problem, the general solution is to increase the size of the copy backlog buffer. This size can generally be calculated using

缓冲区大小=（主库写入命令速度 * 操作大小 - 主从库间网络传输命令速度 * 操作大小）* 2

If the number of concurrent requests is very large, adjust the buffer If the area size method cannot be solved, then you can consider using the slicing cluster method to solve it

4. AOF buffer

The AOF buffer is the buffer set by Redis in AOF persistence. AOF buffer also has two types of AOF buffer and AOF rewrite buffer.

1. AOF buffer

We all know that even for solid-state drives, its reading and writing speed is much different from that of memory. The AOF buffer is mainly set by Redis to solve the problem of the synchronization between the command execution speed of the main process and the disk writing speed. The AOF buffer can effectively avoid frequent reading and writing of the hard disk, thereby improving performance. When performing AOF persistence, Redis will first write the command to the AOF buffer, and then write it to the hard disk AOF file according to the write-back policy.

The overflow of the AOF buffer may be related to the disk writing speed or the AOF write-back strategy. When a large number of commands are backlogged in the AOF buffer and exceed its After setting the threshold, buffer overflow will occur. To avoid this problem, we can solve it by adjusting the writeback strategy or adjusting the AOF buffer size.

2. AOF rewrite buffer

The AOF rewrite buffer is when Redis performs AOF rewriting in the child process. When the parent process accepts a new command, it will write the command Enter the AOF rewrite buffer, wait until the sub-process rewrite is completed, and append the AOF rewrite buffer command to the new AOF file.

The overflow of the AOF rewrite buffer is related to the number of commands processed by the main process during AOF rewriting. When the Redis main process processes a large number of commands during AOF rewriting, , these commands will be written into the AOF rewrite buffer. When the set threshold is exceeded, it will cause overflow.

To avoid overflow of the AOF rewrite buffer, we can also solve it by adjusting the size of the AOF rewrite buffer.

The above is the detailed content of How to solve Redis buffer overflow. For more information, please follow other related articles on the PHP Chinese website!