How redis maintains consistency with mysql

There are two ways to maintain consistency between redis and mysql, which are: 1. Perform the [redis.del(key)] operation before and after writing the database, and set a reasonable timeout; 2. Through The synchronization mechanism based on subscribing to binlog achieves consistency between redis and mysql.

The method to maintain consistency between redis and mysql is to adopt a delayed double delete strategy, first delete the cache and then write to the database; the second method is to update the cache asynchronously. First read Redis and then write mysql and then update the Redis data

The cache and database consistency solutions are as follows:

Method 1: Use delay Double delete strategy

Perform redis.del(key) operation before and after writing the database, and set a reasonable timeout.

The pseudo code is as follows

public void write(String key,Object data){ redis.delKey(key); db.updateData(data); Thread.sleep(500); redis.delKey(key); }

The specific steps are:

(1) Delete the cache first

(2) Then write Database

(3) Sleep for 500 milliseconds

(4) Delete cache again

So, how is this 500 millisecond determined, and how long should it sleep for?

You need to evaluate the time-consuming data reading business logic of your project. The purpose of this is to ensure that the read request ends, and the write request can delete the cached dirty data caused by the read request.

Of course, this strategy also takes into account the time-consuming synchronization between redis and the database master-slave. The final sleep time for writing data: Add a few hundred milliseconds to the time it takes to read data business logic. For example: sleep for 1 second.

Set the cache expiration time

Theoretically, setting the cache expiration time is a solution to ensure eventual consistency. All write operations are subject to the database. As long as the cache expiration time is reached, subsequent read requests will naturally read new values ​​from the database and backfill the cache.

Disadvantages of this solution

Combined with the double delete policy cache timeout setting, the worst case scenario is that the data is inconsistent within the timeout period, and additional write requests are added time consuming.

Method 2: Asynchronous update cache (synchronization mechanism based on subscribing to binlog)

Overall technical idea:

MySQL binlog Incremental subscription consumption message queue incremental data is updated to redis

1) Read Redis: hot data is basically all in Redis

2) Write MySQL: additions, deletions and modifications are all operations MySQL

3) Update Redis data: MySQ’s data operation binlog is updated to Redis

Redis update

(1) Data operations are mainly divided into two blocks:

One is full (write all data to redis at once) and the other is incremental (real-time update)

What we are talking about here is incremental, which refers to update, insert and delete of mysql Change data.

(2) After reading the binlog, analyze it, and use the message queue to push and update the redis cache data of each station.

In this way, once new write, update, delete and other operations occur in MySQL, the binlog related messages can be pushed to Redis, and Redis will update Redis based on the records in the binlog.

In fact, this mechanism is very similar to MySQL's master-slave backup mechanism, because MySQL's master-slave backup also achieves data consistency through binlog.

Here you can use canal (an open source framework of Alibaba), through which you can subscribe to MySQL's binlog, and canal imitates the backup request of mysql's slave database to update Redis data. Achieved the same effect.

Of course, you can also use other third parties for the message push tools here: kafka, rabbitMQ, etc. to implement push updates to Redis

The above is the detailed content of How redis maintains consistency with mysql. For more information, please follow other related articles on the PHP Chinese website!