问题: redis-高并发场景下如何保证缓存数据与数据库的最终一致性

Dlwyz2024-11-22 17:59

在高并发场景下，Redis 通常用作缓存层，与数据库结合使用以提高系统的性能。为了保证缓存数据与数据库的最终一致性，通常采用的有双写机制、缓存失效机制，基于双写机制、缓存失效机制又衍生出来了消息队列、事件驱动架构等

常见机制

常见的机制如下，个人理解无非是先后或各种手段操作数据库、redis，代码ai给写的示列只需看懂即可。

  1. 双写机制
    在更新数据库的同时，同步更新缓存。
    适用于写操作较少的场景
java 复制代码 
 public class CacheService {
       private final JdbcTemplate jdbcTemplate;
       private final RedisTemplate<String, Object> redisTemplate;

       public void updateData(String key, String value) {
           // 更新数据库
           jdbcTemplate.update("UPDATE table SET value = ? WHERE key = ?", value, key);

           // 更新缓存
           redisTemplate.opsForValue().set(key, value);
       }
  1. 缓存失效机制
    在更新数据库后，删除缓存中的旧数据，读取数据时候时写入缓存
    适用于写操作频繁的场景。
java 复制代码 
 public class CacheService {
       private final JdbcTemplate jdbcTemplate;
       private final RedisTemplate<String, Object> redisTemplate;

       public void updateData(String key, String value) {
           // 更新数据库
           jdbcTemplate.update("UPDATE table SET value = ? WHERE key = ?", value, key);

           // 删除缓存
           redisTemplate.delete(key);
       }

       public String getData(String key) {
           // 从缓存中获取数据
           String value = (String) redisTemplate.opsForValue().get(key);
           if (value == null) {
               // 缓存未命中，从数据库中获取数据
               value = jdbcTemplate.queryForObject("SELECT value FROM table WHERE key = ?", new Object[]{key}, String.class);
               if (value != null) {
                   // 将数据写入缓存
                   redisTemplate.opsForValue().set(key, value);
               }
           }
           return value;
       }
   }
  1. 消息队列机制
    使用消息队列异步更新redis，确保数据的一致性。
    适用于高并发写操作的场景。
java 复制代码 
  import com.rabbitmq.client.Channel;
   import com.rabbitmq.client.Connection;
   import com.rabbitmq.client.ConnectionFactory;

   public class CacheService {
       private final JdbcTemplate jdbcTemplate;
       private final RedisTemplate<String, Object> redisTemplate;

       public void updateData(String key, String value) {
           // 更新数据库
           jdbcTemplate.update("UPDATE table SET value = ? WHERE key = ?", value, key);

           // 发送消息到消息队列
           sendUpdateMessage(key, value);
       }

       private void sendUpdateMessage(String key, String value) {
           ConnectionFactory factory = new ConnectionFactory();
           factory.setHost("localhost");
           try (Connection connection = factory.newConnection();
                Channel channel = connection.createChannel()) {
               channel.queueDeclare("cache_update_queue", true, false, false, null);
               channel.basicPublish("", "cache_update_queue", null, (key + ":" + value).getBytes());
           } catch (Exception e) {
               e.printStackTrace();
           }
       }

       public void consumeUpdateMessages() {
           ConnectionFactory factory = new ConnectionFactory();
           factory.setHost("localhost");
           try (Connection connection = factory.newConnection();
                Channel channel = connection.createChannel()) {
               channel.queueDeclare("cache_update_queue", true, false, false, null);
               DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                   String message = new String(delivery.getBody(), "UTF-8");
                   String[] parts = message.split(":");
                   String key = parts[0];
                   String value = parts[1];

                   // 更新缓存
                   redisTemplate.opsForValue().set(key, value);
               };
               channel.basicConsume("cache_update_queue", true, deliverCallback, consumerTag -> {});
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
  1. 事件驱动机制
    使用事件驱动架构，当数据库数据发生变化时，触发事件，事件处理器负责更新缓存。
    适用于复杂的数据更新逻辑。
java 复制代码 
   import org.springframework.context.ApplicationEventPublisher;
   import org.springframework.context.ApplicationEventPublisherAware;
   import org.springframework.stereotype.Service;

   @Service
   public class CacheService implements ApplicationEventPublisherAware {
       private final JdbcTemplate jdbcTemplate;
       private final RedisTemplate<String, Object> redisTemplate;
       private ApplicationEventPublisher eventPublisher;

       public void updateData(String key, String value) {
           // 更新数据库
           jdbcTemplate.update("UPDATE table SET value = ? WHERE key = ?", value, key);

           // 发布事件
           eventPublisher.publishEvent(new DataUpdatedEvent(this, key, value));
       }

       @Override
       public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
           this.eventPublisher = applicationEventPublisher;
       }

       @Service
       public class EventListener {
           private final RedisTemplate<String, Object> redisTemplate;

           @org.springframework.context.event.EventListener
           public void handleDataUpdatedEvent(DataUpdatedEvent event) {
               // 更新缓存
               redisTemplate.opsForValue().set(event.getKey(), event.getValue());
           }
       }
   }

   public class DataUpdatedEvent extends ApplicationEvent {
       private final String key;
       private final String value;

       public DataUpdatedEvent(Object source, String key, String value) {
           super(source);
           this.key = key;
           this.value = value;
       }

       public String getKey() {
           return key;
       }

       public String getValue() {
           return value;
       }
   }
  1. 定期补偿机制
    定期对缓存和数据库的数据进行校验，发现不一致时进行补偿操作。
    适用于对数据一致性要求较高的场景。
java 复制代码 
 import java.util.concurrent.Executors;
   import java.util.concurrent.ScheduledExecutorService;
   import java.util.concurrent.TimeUnit;

   public class DataConsistencyChecker {
       private final JdbcTemplate jdbcTemplate;
       private final RedisTemplate<String, Object> redisTemplate;
       private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

       public void startChecking() {
           scheduler.scheduleAtFixedRate(() -> {
               // 从数据库中获取所有数据
               List<Map<String, Object>> dataFromDB = jdbcTemplate.queryForList("SELECT key, value FROM table");

               for (Map<String, Object> row : dataFromDB) {
                   String key = (String) row.get("key");
                   String value = (String) row.get("value");

                   // 从缓存中获取数据
                   String cacheValue = (String) redisTemplate.opsForValue().get(key);

                   if (!value.equals(cacheValue)) {
                       // 数据不一致，更新缓存
                       redisTemplate.opsForValue().set(key, value);
                   }
               }
           }, 0, 1, TimeUnit.HOURS);
       }
   }

废弃缓存与更新缓存的取舍

由上面代码可看出 1和2 最大的区别在于更新数据库时到底是更新缓存还是删除缓存。

【废弃缓存】

优点：

操作简单，只需在更新数据库后删除缓存，下次读取时重新从数据库加载数据，减少了写的操作日数

缺点：

可能短暂不一致：在缓存删除后和新数据写入缓存前，可能会出现短暂的缓存不一致

【更新缓存】

优点：

数据强一致性：更新数据库和缓存同时进行，确保数据的一致性。

减少数据库读压力：缓存始终是最新的，减少了对数据库的读操作。

缺点：

复杂性增加：需要处理缓存更新失败的情况，可能需要回滚操作。

性能影响：每次更新操作都需要同时更新数据库和缓存，增加了操作的复杂性和时间

  • 写操作较少的场景：
    推荐使用更新缓存：因为写操作较少，更新缓存的额外开销相对较小，且可以确保数据的一致性。
  • 写操作频繁的场景：
    推荐使用废弃缓存：因为写操作频繁，更新缓存会增加系统的复杂性和开销，而废弃缓存可以减少缓存的写操作，降低系统负担。
  • 对数据一致性要求极高的场景：
    推荐使用更新缓存：尽管复杂性增加，但可以确保数据的强一致性。
  • 对性能要求较高且可以容忍短暂不一致的场景：
    推荐使用废弃缓存：可以减少数据库的读压力，提高系统的整体性能

淘汰缓存的顺序

https://blog.csdn.net/qq_39033181/article/details/119276120

【 方案一 】先淘汰缓存，再更新数据库

在并发量较大的情况下，会导致数据的不一致。

1. A线程进行写操作，先成功淘汰缓存，但由于网络或其它原因，还未更新数据库

2. B线程进行读操作，发现缓存中没有想要的数据，从数据库中读取到的是旧数据，并把旧数据放入缓存。此时数据库与缓存都是旧值，数据没有不一致

3. A线程将数据库更新完成，数据库中是更新后的新数据，缓存中是更新前的旧数据，造成数据不一致。

【 方案二 】先更新数据库，再淘汰缓存

在并发量较大的情况下，会导致数据的短暂不一致，但是数据会最终一致。

1. A线程进行写操作，更新数据库，还未淘汰缓存

2. B线程从缓存中可以读取到旧数据，此时数据不一致

3. A线程完成淘汰缓存操作，其它线程进行读操作，从数据库中读入最新数据，此时数据一致

延时双删

上述方案二更简单，在高并发场景下也能保证数据的最终一致性，但是如果我就想用方案一呢？

什么是延时双删

先删再更新数据库 过N秒后再删一次缓存，怎么实现放后面spring-cache集成里，大概有 1.延时队列、2.线程池实现延时任务。

小结

  • 这些都是理论，真正写代码，有cache框架，哪有这么烦，很多人喜欢问，那我们就得理，理了总比不理好，写这个就是怕我自己忘，呵
  • 无论怎么样在高并发场景下，我们也只能要求缓存数据与数据库的最终一致性，如果要求强一致性还要缓存干嘛呢？操作直接走DB更香
  • 大多数情况下建议使用淘汰缓存机制，然后先更新数据库，再淘汰缓存，满足大多数的场景了
相关推荐
liutaiyi85 分钟前
Redis可视化工具 RDM mac安装使用
redis·后端·macos
Fool丶玄浅8 分钟前
【数据库系统概论】—— 关系数据库
数据库·数据库系统
DashVector40 分钟前
如何通过HTTP API检索Doc
数据库·人工智能·http·阿里云·数据库开发·向量检索
SEO-狼术1 小时前
Enhance Security in Software Crack
数据库
qq_372006862 小时前
浏览器http缓存问题
网络协议·http·缓存
计算机毕设定制辅导-无忧学长2 小时前
Redis 初相识：开启缓存世界大门
数据库·redis·缓存
爱吃南瓜的北瓜2 小时前
双重判定锁来解决缓存击穿问题
缓存
Rverdoser2 小时前
redis延迟队列
数据库·redis·缓存
weisian1513 小时前
Redis篇--常见问题篇6--缓存一致性1（Mysql和Redis缓存一致，更新数据库删除缓存策略）
数据库·redis·缓存
记得开心一点嘛4 小时前
高并发处理 --- Caffeine内存缓存库
缓存·caffeine
热门推荐
0119个Web前端交互式3D JavaScript框架和库02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04RAG 实践- Ollama+RagFlow 部署本地知识库05【一文读懂】NTN（非地面网络）技术介绍06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07ZZ038 物联网应用与服务赛题第J套08组基轨迹建模 GBTM的介绍与实现（Stata 或 R）09Docker 夺命连环 15 问10VSCode插件 —— Cody AI （免费AI助手！）