一、缓存双写问题的由来
在开发中，我们经常会用到缓存来提高系统的性能。就好比我们去超市买东西，有些常用的商品我们会多备一些放在家里，这样下次需要的时候就不用再跑去超市了，能节省时间。在计算机里，Redis 就像是家里的小仓库，数据库就像是超市。我们把经常要用的数据放在 Redis 这个小仓库里，程序需要数据的时候就先去 Redis 里找，这样能提高访问速度。
但是这里就有个问题了，当数据发生变化的时候，我们既要更新数据库，又要更新 Redis 里的数据，这就是所谓的“双写”。如果更新数据库和更新 Redis 的操作没有协调好，就会出现数据不一致的情况。比如说，我们去超市买了新的商品，但是忘记更新家里小仓库的库存记录了，下次要用的时候就会以为家里还有，结果发现没有了。
二、常见的缓存双写场景及问题
1. 先更新数据库，再更新缓存
这种方式看起来很直观，就像我们去超市买了新商品，然后马上更新家里小仓库的库存记录。但是这里有个问题，如果更新缓存的时候失败了，就会导致数据库里的数据和 Redis 里的数据不一致。
举个例子，我们用 Java 来模拟这个场景：
// Java 技术栈示例
import redis.clients.jedis.Jedis;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class UpdateDBThenCache {
public static void main(String[] args) {
// 假设我们要更新用户的姓名
String userId = "1";
String newName = "John";
// 先更新数据库
try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password")) {
String sql = "UPDATE users SET name = ? WHERE id = ?";
try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
preparedStatement.setString(1, newName);
preparedStatement.setString(2, userId);
preparedStatement.executeUpdate();
}
} catch (SQLException e) {
e.printStackTrace();
}
// 再更新缓存
try (Jedis jedis = new Jedis("localhost", 6379)) {
// 模拟更新缓存失败
if (Math.random() < 0.2) {
throw new RuntimeException("Update cache failed");
}
jedis.hset("user:" + userId, "name", newName);
} catch (Exception e) {
System.out.println("Failed to update cache: " + e.getMessage());
}
}
}
在这个例子中，我们先更新了数据库里用户的姓名，然后尝试更新 Redis 里的缓存。但是如果更新缓存失败了，数据库里的姓名已经更新，而 Redis 里的姓名还是旧的，就会出现数据不一致的情况。
2. 先更新缓存，再更新数据库
这种方式也有问题。如果更新数据库失败了，而缓存已经更新，那么下次从缓存里获取的数据就是错误的。就好比我们先更新了家里小仓库的库存记录，但是去超市买商品的时候发现没货了，这样家里小仓库的库存记录就和超市里的实际情况不一致了。
以下是 Java 示例：
// Java 技术栈示例
import redis.clients.jedis.Jedis;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class UpdateCacheThenDB {
public static void main(String[] args) {
// 假设我们要更新用户的年龄
String userId = "1";
int newAge = 30;
// 先更新缓存
try (Jedis jedis = new Jedis("localhost", 6379)) {
jedis.hset("user:" + userId, "age", String.valueOf(newAge));
}
// 再更新数据库
try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password")) {
// 模拟更新数据库失败
if (Math.random() < 0.2) {
throw new SQLException("Update database failed");
}
String sql = "UPDATE users SET age = ? WHERE id = ?";
try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
preparedStatement.setInt(1, newAge);
preparedStatement.setString(2, userId);
preparedStatement.executeUpdate();
}
} catch (SQLException e) {
System.out.println("Failed to update database: " + e.getMessage());
}
}
}
在这个例子中，我们先更新了 Redis 里用户的年龄，然后尝试更新数据库。如果更新数据库失败了，Redis 里的年龄已经更新，而数据库里的年龄还是旧的，就会导致数据不一致。
三、解决方案
1. 先删除缓存，再更新数据库
这种方案是先把 Redis 里的缓存删除，然后再更新数据库。这样下次程序访问数据的时候，发现 Redis 里没有缓存，就会从数据库里获取最新的数据，并重新缓存到 Redis 里。
以下是 Java 示例：
// Java 技术栈示例
import redis.clients.jedis.Jedis;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class DeleteCacheThenUpdateDB {
public static void main(String[] args) {
// 假设我们要更新用户的地址
String userId = "1";
String newAddress = "New York";
// 先删除缓存
try (Jedis jedis = new Jedis("localhost", 6379)) {
jedis.del("user:" + userId);
}
// 再更新数据库
try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password")) {
String sql = "UPDATE users SET address = ? WHERE id = ?";
try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
preparedStatement.setString(1, newAddress);
preparedStatement.setString(2, userId);
preparedStatement.executeUpdate();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
不过这种方案也有问题，如果在删除缓存之后，更新数据库之前，有其他程序访问了数据，就会把旧的数据重新缓存到 Redis 里，导致数据不一致。
2. 延迟双删策略
为了解决上面的问题，我们可以采用延迟双删策略。就是在更新数据库之后，再延迟一段时间删除一次缓存。这样可以确保在更新数据库的过程中，即使有其他程序把旧的数据重新缓存到 Redis 里，也会被第二次删除操作清理掉。
以下是 Java 示例：
// Java 技术栈示例
import redis.clients.jedis.Jedis;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.concurrent.TimeUnit;
public class DelayedDoubleDelete {
public static void main(String[] args) {
// 假设我们要更新用户的电话
String userId = "1";
String newPhone = "123456789";
// 先删除缓存
try (Jedis jedis = new Jedis("localhost", 6379)) {
jedis.del("user:" + userId);
}
// 再更新数据库
try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password")) {
String sql = "UPDATE users SET phone = ? WHERE id = ?";
try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
preparedStatement.setString(1, newPhone);
preparedStatement.setString(2, userId);
preparedStatement.executeUpdate();
}
} catch (SQLException e) {
e.printStackTrace();
}
// 延迟一段时间后再次删除缓存
try {
TimeUnit.SECONDS.sleep(1); // 延迟 1 秒
try (Jedis jedis = new Jedis("localhost", 6379)) {
jedis.del("user:" + userId);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
3. 消息队列异步更新
我们还可以使用消息队列来异步更新缓存。当数据库更新之后，发送一条消息到消息队列，然后有专门的消费者从消息队列里获取消息，并更新 Redis 里的缓存。
以下是 Java 结合 RabbitMQ 的示例：
// Java 技术栈示例
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import redis.clients.jedis.Jedis;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class MQAsyncUpdate {
private static final String QUEUE_NAME = "cache_update_queue";
public static void main(String[] args) {
// 假设我们要更新用户的邮箱
String userId = "1";
String newEmail = "test@example.com";
// 更新数据库
try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password")) {
String sql = "UPDATE users SET email = ? WHERE id = ?";
try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
preparedStatement.setString(1, newEmail);
preparedStatement.setString(2, userId);
preparedStatement.executeUpdate();
}
} catch (SQLException e) {
e.printStackTrace();
}
// 发送消息到消息队列
try {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
try (Connection connection = factory.newConnection();
Channel channel = connection.createChannel()) {
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
String message = userId + ":" + newEmail;
channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
System.out.println(" [x] Sent '" + message + "'");
}
} catch (Exception e) {
e.printStackTrace();
}
}
// 消费者代码
public static class CacheUpdateConsumer {
public static void main(String[] args) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
channel.basicConsume(QUEUE_NAME, true, (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
String[] parts = message.split(":");
String userId = parts[0];
String newEmail = parts[1];
// 更新 Redis 缓存
try (Jedis jedis = new Jedis("localhost", 6379)) {
jedis.hset("user:" + userId, "email", newEmail);
}
}, consumerTag -> { });
}
}
}
四、应用场景
1. 高并发场景
在高并发的系统中，缓存可以大大提高系统的性能。比如电商系统，在促销活动期间，会有大量的用户访问商品信息。如果每次都从数据库里获取数据，数据库的压力会非常大。这时候就可以使用 Redis 作为缓存，把商品信息缓存起来。但是在商品信息更新的时候，就需要保证 Redis 和数据库的数据一致性，避免出现用户看到的商品信息和实际情况不符的问题。
2. 数据实时性要求较高的场景
有些系统对数据的实时性要求比较高，比如金融系统。在进行交易的时候，需要保证账户余额等信息的实时更新。这时候就需要确保 Redis 和数据库的数据一致，避免出现交易错误。
五、技术优缺点
1. 采用缓存的优点
- 提高性能：缓存可以减少对数据库的访问，从而提高系统的响应速度。就像我们从家里的小仓库拿东西比去超市拿东西要快很多一样。
- 减轻数据库压力：当有大量的请求时，缓存可以承担一部分请求，减少数据库的负载。
2. 缓存双写带来的缺点
- 数据不一致风险：如果处理不当，会导致 Redis 和数据库的数据不一致，影响系统的准确性。
- 复杂性增加：为了保证数据一致性，需要采用一些复杂的解决方案，增加了系统的开发和维护难度。
六、注意事项
1. 缓存过期时间设置
合理设置缓存的过期时间很重要。如果过期时间设置得太短，会导致频繁地从数据库里获取数据，增加数据库的压力；如果过期时间设置得太长，会导致缓存里的数据长时间得不到更新，出现数据不一致的情况。
2. 异常处理
在更新数据库和缓存的过程中，可能会出现各种异常。比如网络故障、数据库连接失败等。需要对这些异常进行合理的处理，避免数据不一致。
3. 并发控制
在高并发场景下，需要考虑并发控制的问题。比如多个线程同时更新数据库和缓存，可能会导致数据不一致。可以采用锁机制或者乐观锁等方式来解决。
七、文章总结
在开发中，使用 Redis 作为缓存可以提高系统的性能，但是缓存双写问题会导致数据不一致。为了解决这个问题，我们可以采用先删除缓存再更新数据库、延迟双删策略、消息队列异步更新等方案。不同的方案有不同的优缺点，需要根据具体的应用场景来选择合适的方案。同时，在使用缓存的过程中，还需要注意缓存过期时间设置、异常处理和并发控制等问题，以确保 Redis 和数据库的数据一致性。
评论