PSYNC is a partial resynchronization mechanism in Redis master-slave replication, which is used to synchronize only data lost during disconnection after the slave server is disconnected to improve synchronization efficiency. Its core relies on the Replication Backlog, which is a queue maintained by the main server. The default size is 1MB and saves the most recently executed write commands. When the slave server reconnects, the PSYNC command will be sent, and the master server will determine whether partial synchronization can be performed: 1. The runid must be consistent; 2. The offset must be in the backlog buffer. If the condition is satisfied, data will continue to be sent from the offset, otherwise full synchronization will be triggered. Methods to improve the success rate of PSYNC include: 1. Appropriately increase the repl-backlog-size; 2. Keep the master-slave network stable; 3. Reasonably set the recovery strategy after the slave server restart. It should be noted that restarting the main server will cause runid changes, causing PSYNC to be invalid, and full synchronization must be performed.

PSYNC, which is partial resynchronization, is a mechanism used by Redis to optimize data synchronization efficiency after disconnection and reconnection during master-slave replication. Simply put, when the slave server is temporarily disconnected due to network fluctuations and other reasons, and then reconnects to the main server, Redis will not directly perform full resynchronization, but instead try to synchronize only the part of the data lost during disconnection. This is the core role of PSYNC.

What is a Replication Backlog?

The key to PSYNC is that the Redis master server maintains a queue called "replication backlog buffer". This queue saves write commands executed by the main server in the last period of time (stored in Redis protocol format). When the slave server disconnects and reconnects, it will tell the master server which offset it has been processed, and the master server will check whether the offset is still present in the backlog buffer.

• If it exists, the corresponding data can be retrieved from it and sent to the slave server to complete partial synchronization;
• If it does not exist (for example, if the disconnection time is too long and the backlog buffer has overwritten this part of the data), then you can only perform full synchronization once.

This buffer has a size limit, the default is 1MB, which can be adjusted through repl-backlog-size configuration item.

How to initiate a PSYNC request from the server?

When the slave reconnects to the master, it sends a PSYNC <runid> <offset></offset></runid> command:

• <runid></runid> is the run ID of the main server that was last connected;
• <offset></offset> is the location currently received and processed from the server.

After receiving this request, the main server will determine two conditions:

• Is the current runid of the master server consistent with the runid sent from the server?
• Is the offset requested from the server still within the replication backlog buffer range?

If all are met, the master server will send subsequent commands from that offset, otherwise it will enter the full synchronization process.

How to improve PSYNC success rate?

To make PSYNC more successful and avoid frequent triggering of full synchronization, you can start from the following aspects:

• Appropriately increase the replication backlog buffer : If your business writes are large, 1MB may be overwritten soon. Repl-backlog-size can be increased as needed.
• Control network stability between master and slave : Although we cannot completely avoid network problems, deploying as much as possible in low-latency, stable network environments can help reduce unnecessary full synchronization.
• Reasonably set the recovery strategy after the slave server restart : For example, when restarting the slave server, if you know that the master server will not change much in a short period of time, you can try to use the previously saved runid and offset to initiate a PSYNC request.

It should be noted that PSYNC is not suitable for all scenarios. For example, after the master server restarts, the runid will change. At this time, even if the slave server is connected, partial synchronization cannot be performed, and full synchronization must be performed.

Basically that's it. PSYNC is designed to improve the efficiency of master-slave synchronization. Understanding its mechanism can help you better optimize Redis replication performance, especially in scenarios where network is unstable or write pressure is high.

The above is the detailed content of How does PSYNC (partial resynchronization) work?. For more information, please follow other related articles on the PHP Chinese website!