Redis教程(二十一)：Redis怎么保证缓存一致性

已于 2024-06-18 09:49:02 修改
阅读量1k 收藏 9
点赞数 32
分类专栏： Redis从入门到精通 文章标签： 缓存 redis 数据库
于 2024-05-29 07:57:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44853310/article/details/139282292
版权

 传送门：Redis教程汇总篇，让你从入门到精通

Redis 的缓存一致性

Redis 的缓存一致性是指在使用 Redis 作为缓存层时，保证缓存中的数据与数据库中的数据保持一致的状态。在分布式系统中，数据一致性是一个重要的问题，因为可能存在多个客户端同时读写同一数据，或者数据在不同节点间需要同步更新。

 

在涉及缓存的场景中，保持缓存一致性面临以下挑战：

 

  1. 数据更新：当数据库中的数据被修改后，相关联的缓存数据需要被相应地更新或失效，以避免返回陈旧的数据。

  2. 数据失效：当缓存的数据被认定为过时（可以是时间过期，或者因为底层数据有变更）时，必须从缓存中移除，以确保下次读取会从后端数据库加载最新数据。

  3. 数据同步：在分布式缓存环境中，相同的数据可能会存储在多个缓存节点上。这就要求所有的节点在数据变化时保持同步，从而确保数据的一致性。

 

为了处理这些挑战，你可以采取以下几种常见的方法保证缓存一致性：

 

强一致性

 

确保缓存和数据库的写入操作是原子的，即任何时刻，所有客户端看到的数据总是最新的。在实践中，这通常需要使用分布式锁或事务来实现，但可能会带来性能上的开销。

 

弱一致性

 

接受在短时间内缓存数据可能不同步的情况，但确保在一定时间后能够达到一致性。例如，可以通过设置缓存的过期时间来自动让旧数据失效。

 

缓存更新策略

 

比如采用“写入时更新”（Write-through）、“写入后更新”（Write-behind）等策略，这些策略定义了不同的数据同步时机和方式。

 

维护缓存和数据库的一致性可能会很复杂，需要在数据的实时性（一致性）和系统的性能之间做权衡。正确的缓存策略和实现细节取决于具体的应用场景和对数据一致性的需求。

缓存一致性

首先，我们首先明确什么是缓存一致性：

  • 缓存中有数据，那么，缓存的数据值需要和数据库中的值相同；
  • 缓存中本身没有数据，那么，数据库中的值必须是最新值。

缓存同步策略

  • 先更新缓存，再更新数据库；
  • 先更新数据库，再更新缓存；
  • 先删除缓存，再更新数据库；
  • 先更新数据库，再删除缓存；
  • 先删除缓存，再更新数据库，延迟一会后，再删除缓存（延迟双删）；

代码实现

用一个HashMap模拟数据库存储

package com.single.conherence;

import java.util.HashMap;
import java.util.Map;

/**
 * @program: RedisDemo
 * @description:
 * @author: fudingwei
 * @create: 2024-05-28 11:39
 **/
public class DataBaseConstant {
    public static final Map<String,String> DATA_MAP = new HashMap<String,String>();
}

1、先更新缓存，再更新数据库

package com.single.conherence;

import org.redisson.Redisson;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.redisson.config.Config;

import java.util.Date;
import java.util.concurrent.TimeUnit;

import static com.single.conherence.DataBaseConstant.DATA_MAP;

/**
 * @program: RedisDemo
 * @description: 先更新缓存，再更新数据库，A,B两个线程
 * @author: fudingwei
 * @create: 2024-05-28 11:12
 **/
public class RedisTest1 {
    public static void main(String[] args) throws InterruptedException {
        //1、A更新缓存为 apple，然后出现网络延迟，A暂停
        //2、B过来更新缓存 peer，更新数据库 peer
        //3、A继续更新数据库 apple，就会导致数据不一致问题

        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        StringCodec stringCodec = new StringCodec();
        config.setCodec(stringCodec);
        RedissonClient redisson = Redisson.create(config);
        RBucket<Object> fdw = redisson.getBucket("fdw");

        //线程A
        Thread t1 = new Thread(()->{
            fdw.set("apple");
            System.out.println("A更新缓存: "+"apple");
            try {
                //由于网络延迟，暂停3秒
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            DATA_MAP.put("fdw","apple");
            System.out.println("A更新数据库: "+"apple");
        });

        //线程B
        Thread t2 = new Thread(()->{
            fdw.set("peer");
            System.out.println("B更新缓存: "+"peer");
            DATA_MAP.put("fdw","peer");
            System.out.println("B更新数据库: "+"peer");
        });

        //启动两个线程
        t1.start();
        try {
            //暂停1秒，B在A之后启动，
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

        //等待两个线程执行
        t1.join();
        t2.join();

        System.out.println("两个线程执行完毕！");
        System.out.println("现在缓存中的值："+fdw.get());
        System.out.println("现在数据库中的值："+DATA_MAP.get("fdw"));

        System.exit(0);

    }
}

测试结果：

2、先更新数据库，再更新缓存

package com.single.conherence;

import org.redisson.Redisson;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.redisson.config.Config;

import java.util.concurrent.TimeUnit;

import static com.single.conherence.DataBaseConstant.DATA_MAP;

/**
 * @program: RedisDemo
 * @description: 先更新数据库，再更新缓存，A,B两个线程
 * @author: fudingwei
 * @create: 2024-05-28 11:12
 **/
public class RedisTest2 {
    public static void main(String[] args) throws InterruptedException {
        //1、A更新数据库为 apple，然后出现网络延迟，A暂停
        //2、B过来更新数据库为 peer，更新缓存为 peer
        //3、A继续更新缓存为 apple，就会导致数据不一致问题

        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        StringCodec stringCodec = new StringCodec();
        config.setCodec(stringCodec);
        RedissonClient redisson = Redisson.create(config);
        RBucket<Object> fdw = redisson.getBucket("fdw");

        //线程A
        Thread t1 = new Thread(()->{
            DATA_MAP.put("fdw","apple");
            System.out.println("A更新数据库: "+"apple");
            try {
                //由于网络延迟，暂停3秒
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            fdw.set("apple");
            System.out.println("A更新缓存: "+"apple");

        });

        //线程B
        Thread t2 = new Thread(()->{
            DATA_MAP.put("fdw","peer");
            System.out.println("B更新数据库: "+"peer");

            fdw.set("peer");
            System.out.println("B更新缓存: "+"peer");
        });

        //启动两个线程
        t1.start();
        try {
            //暂停1秒，B在A之后启动，
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

        //等待两个线程执行
        t1.join();
        t2.join();

        System.out.println("两个线程执行完毕！");
        System.out.println("现在缓存中的值："+fdw.get());
        System.out.println("现在数据库中的值："+DATA_MAP.get("fdw"));

        System.exit(0);

    }
}

测试结果：

3、先删除缓存，再更新数据库

package com.single.conherence;

import org.redisson.Redisson;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.redisson.config.Config;

import java.util.concurrent.TimeUnit;

import static com.single.conherence.DataBaseConstant.DATA_MAP;

/**
 * @program: RedisDemo
 * @description: A先删除缓存，再更新数据库，B查询缓存，没有查到就查数据库，再更新到缓存
 * （因为两个线程都是删除缓存话不存在缓存不一致的问题，没有研究价值，这里测试一删一查的情况）
 * @author: fudingwei
 * @create: 2024-05-28 11:12
 **/
public class RedisTest3 {
    public static void main(String[] args) throws InterruptedException {
        //1、A先删除缓存，然后出现网络延迟，A暂停
        //2、B过来查询缓存为空，然后查询数据库为peer，更新缓存为peer
        //3、A继续更新数据库为 apple，就会导致数据不一致问题

        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        StringCodec stringCodec = new StringCodec();
        config.setCodec(stringCodec);
        RedissonClient redisson = Redisson.create(config);
        RBucket<Object> fdw = redisson.getBucket("fdw");
        DATA_MAP.put("fdw","peer");
        fdw.set("peer");

        //线程A
        Thread t1 = new Thread(()->{
            fdw.delete();
            System.out.println("A删除缓存");

            try {
                //由于网络延迟，暂停3秒
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            DATA_MAP.put("fdw","apple");
            System.out.println("A更新数据库: "+"apple");
        });

        //线程B
        Thread t2 = new Thread(()->{
            Object o = fdw.get();
            if(null==o){
                //查询数据库
                String fdwData = DATA_MAP.get("fdw");
                //更新到缓存
                fdw.set(fdwData);
                System.out.println("B更新到缓存: "+fdwData);
            }
        });

        //启动两个线程
        t1.start();
        try {
            //暂停1秒，B在A之后启动，
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

        //等待两个线程执行
        t1.join();
        t2.join();

        System.out.println("两个线程执行完毕！");
        System.out.println("现在缓存中的值："+fdw.get());
        System.out.println("现在数据库中的值："+DATA_MAP.get("fdw"));

        System.exit(0);
    }
}

测试结果：

4、先更新数据库，再删除缓存（推荐方式）

package com.single.conherence;

import org.redisson.Redisson;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.redisson.config.Config;

import java.util.concurrent.TimeUnit;

import static com.single.conherence.DataBaseConstant.DATA_MAP;

/**
 * @program: RedisDemo
 * @description: A先更新数据库，再删除缓存（推荐方式），B查询缓存，没有就查数据库，再更新到缓存
 * （因为两个线程都是删除缓存话不存在缓存不一致的问题，没有研究价值，这里测试一删一查的情况）
 * @author: fudingwei
 * @create: 2024-05-28 11:12
 **/
public class RedisTest4 {
    public static void main(String[] args) throws InterruptedException {
        //1、A更新数据库为 apple，然后出现网络延迟，A暂停
        //2、B过来查询缓存为 peer，可能会出现短暂的数据不一致现象
        //3、A继续删除缓存，最终数据是一致的

        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        StringCodec stringCodec = new StringCodec();
        config.setCodec(stringCodec);
        RedissonClient redisson = Redisson.create(config);
        RBucket<Object> fdw = redisson.getBucket("fdw");
        DATA_MAP.put("fdw","peer");
        fdw.set("peer");

        //线程A
        Thread t1 = new Thread(()->{
            DATA_MAP.put("fdw","apple");
            System.out.println("A更新数据库: "+"apple");
            try {
                //由于网络延迟，暂停3秒
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //这边需要有删除失败，重试的机制！！！
            fdw.delete();
            System.out.println("A删除缓存");
        });

        //线程B
        Thread t2 = new Thread(()->{
            Object o = fdw.get();

            if(null == o){
                //缓存没有就查数据库
                String fdwData = DATA_MAP.get("fdw");
                //更新缓存
                fdw.set(fdwData);
            }else {
                System.out.println("B查询到的值："+o);
            }
        });

        //启动两个线程
        t1.start();
        try {
            //暂停1秒，B在A之后启动，
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

        //等待两个线程执行
        t1.join();
        t2.join();

        System.out.println("两个线程执行完毕！");
        System.out.println("现在缓存中的值："+fdw.get());
        System.out.println("现在数据库中的值："+DATA_MAP.get("fdw"));

        System.exit(0);
    }
}

测试结果：

注意：这样虽然可能有短暂的数据不一致现象，但保证了最终一致性，要注意第二步可能有删除缓存失败的问题，所以需要有删除重试机制。

5、先删除缓存，再更新数据库，延迟一会后，再删除缓存（延迟双删）

package com.single.conherence;

import org.redisson.Redisson;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.redisson.config.Config;

import java.util.concurrent.TimeUnit;

import static com.single.conherence.DataBaseConstant.DATA_MAP;

/**
 * @program: RedisDemo
 * @description: A先删除缓存，再更新数据库，B查询缓存，没有查到就查数据库，再更新到缓存，A等待一段时间后（等B更新完缓存），删除缓存
 * （延迟双删策略）
 * @author: fudingwei
 * @create: 2024-05-28 11:12
 **/
public class RedisTest5 {
    public static void main(String[] args) throws InterruptedException {
        //1、A先删除缓存，然后出现网络延迟，A暂停
        //2、B过来查询缓存为空，然后查询数据库为peer，更新缓存为peer
        //3、A继续更新数据库为 apple，就会导致数据不一致问题

        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        StringCodec stringCodec = new StringCodec();
        config.setCodec(stringCodec);
        RedissonClient redisson = Redisson.create(config);
        RBucket<Object> fdw = redisson.getBucket("fdw");
        DATA_MAP.put("fdw","peer");
        fdw.set("peer");

        //线程A
        Thread t1 = new Thread(()->{
            fdw.delete();
            System.out.println("A删除缓存");

            try {
                //由于网络延迟，暂停3秒
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            DATA_MAP.put("fdw","apple");
            System.out.println("A更新数据库: "+"apple");


            try {
                //故意延迟2秒，再删除缓存
                TimeUnit.SECONDS.sleep(2);
                fdw.delete();
                System.out.println("A延迟删除缓存");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });

        //线程B
        Thread t2 = new Thread(()->{
            Object o = fdw.get();
            if(null==o){
                //查询数据库
                String fdwData = DATA_MAP.get("fdw");
                //更新到缓存
                fdw.set(fdwData);
                System.out.println("B更新到缓存: "+fdwData);
            }
        });

        //启动两个线程
        t1.start();
        try {
            //暂停1秒，B在A之后启动，
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

        //等待两个线程执行
        t1.join();
        t2.join();

        System.out.println("两个线程执行完毕！");
        System.out.println("现在缓存中的值："+fdw.get());
        System.out.println("现在数据库中的值："+DATA_MAP.get("fdw"));

        System.exit(0);
    }
}

测试结果：

注意：这个延迟时间是要大于 B线程【查数据库然后更新缓存所需的时间】 ，这个要根据业务来确定，一般很难确定，所以这种方案不常用。

最优方案

以上几种方式中推荐使用【4、先更新数据库，再删除缓存】，但如果对一致性要求较高的话，目前最好的缓存同步方案是使用阿里的Canal组件,该组件只适用于MySQL，它的原理是把自己模拟成一台MySQL的从机，从主机获取binlog日志，通过解析binlog日志获取到数据的变化，再同步到Redis缓存，保证强一致性！

ThatMonth
关注
  • 32
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Mysql/Redis缓存一致性
qq_64948664的博客
03-10 1254
如何保证MySQL和Redis的缓存一致。从理论到实战。总结6种来感受一下。
redis-cache:使用Redis的缓存服务
04-03
3. 分布式锁：在并发环境下，可以使用Redis的分布式锁机制保证数据一致性。 4. 监控与调优：监控Redis的性能指标，如内存使用、QPS（每秒查询次数）等，适时调整参数以优化性能。 总结，"redis-cache"项目旨在利用...
Redis：缓存一致性问题（缓存更新策略）
机械工程跑路哥
02-22 1230
缓存的一致性即当对数据库修改，缓存未更改，就出现了缓存一致性的问题；
SpringBoot整合Redis：Redis优化解决数据一致性问题
热门推荐
终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路
03-21 3万+
​ 本期我们重点讲一个后端的必考面试题 也是开发中常遇到的问题--数据一致性问题 上一期我们讲到了 SpringBoot如何结合Redis做一个缓存 实现我们减少对数据库压力的一个目的。还不知道怎么做的小伙伴可以先回顾一下前文http://t.csdnimg.cn/tshRD ​
2024年最全Redis怎么保持缓存与数据库一致性？，不愧是阿里P8
2401_84976662的博客
05-13 885
这么做引发的问题是，如果A,B两个线程同时要更新数据，并且A,B已经都做完了删除缓存这一步，接下来，A先更新了数据库，C线程读取数据，由于缓存没有，则查数据库，并把A更新的数据，写入了缓存，最后B更新数据库。这么做引发的问题是，如果A,B两个线程同时做数据更新，A先更新了数据库，B后更新数据库，则此时数据库里存的是B的数据。这样缓存和数据库的数据也不一致。按照我提到的这种更新缓存的策略，理论上也是有不一致的风险的，之前在其他的博客文章有看到过，只不过概率很小，我们暂时可以不考虑，后面我们有其他手段来补救。
Redis-数据库和缓存如何保证一致性？
barret的博客
11-09 3582
Redis--数据库和缓存如何保证一致性
go-redis-cache:使用Redis缓存进行微服务
04-11
通过正确地使用Redis缓存，我们可以提升微服务的性能，减少数据库负载，同时确保数据一致性。在实际开发过程中，根据业务需求选择合适的缓存策略，结合监控和调优工具，可以更好地发挥Redis缓存的优势。
redis-cache:Redis缓存
03-30
- 数据一致性：缓存与数据库双写时需处理一致性问题。 - 缓存击穿：热点key失效时可能导致大量请求直接到数据库，应设置合理的过期时间或使用随机过期策略。 - 缓存雪崩：大量缓存同时失效，应避免设置同一过期...
Redis：高效的数据存储与缓存解决方案
05-16
AOF记录所有写操作，保证数据的一致性，适合增量恢复。 5. **性能优化** - 压缩：Redis可以通过LZF或ZSTD等算法压缩数据，减少内存使用。 - 避免阻塞：通过多线程I/O复用模型避免主线程阻塞，提高并发处理能力。 ...
springboot缓存一致性解决
09-03
在Spring Boot应用中，缓存一致性是一个重要的议题，特别是在分布式系统中，多个节点可能同时访问并更新同一数据，导致缓存中的数据不一致。本文将深入探讨Spring Boot中如何处理和解决缓存一致性问题。 首先，我们...
Vue3 对跳转 同一路由传入不同参数的页面分别进行缓存
qq_43225508的博客
07-06 756
watch 监听对于route.query 是否存在catchName 参数的路由分别进行缓存。path: '/myRouter/detail', // 路径。从列表页跳转至不同的详情页面，对这些详情页面分别进行缓存。keepAlive: true, // 是否被缓存。在路由文件里对需要进行缓存的路由对象添加meta 属性。-- 有条件的进行缓存 -->// 需要缓存的详情页面路由。
黑马点评商户缓存查询作业——Redis中查询商户类型
weixin_45791946的博客
07-08 254
一共分为几个步骤要注意一下的就是查询数据库的过程用到了Mapper，记得用@Autowired自动注入一下ShopTypeMapper。
keep-alive缓存组件
m0_54007573的博客
07-08 422
keep-alive缓存组件
Vue3 对于内嵌Iframe组件进行缓存
qq_43225508的博客
07-06 1022
对于系统内所有内嵌iframe 的页面均通过同一个路由'/iframe', 在router.query内传入不同src 参数，在同一组件内显示iframe 内嵌页面，对这些页面分别进行缓存。3.4 在template 部分增加 组件通过v-show 控制ifram 路由缓存的组件是否渲染。// 保存相同iframe 组件修改之后的组件名称同iframe套壳组件的映射关系。3.3 对同一iframe 路由传入不同参数的组件套壳修改name 进行缓存。-- iframe 组件缓存 -->
redis学习(008 实战:黑马点评:缓存介绍)
最新发布
wang_book的博客
07-11 269
延迟双删，先操作数据库注解Cacheable我们后面再讲。
DNS缓存详解
qq_62311779的博客
07-09 476
1.浏览器查找顺序 浏览器缓存 > 操作系统缓存 > 本地Hosts文件 > DNS服务器查询 2.cmd ping查找顺序（非浏览器） 本地Hosts文件 > 操作系统缓存 > DNS服务器查询
Nginx 高效加速策略：动静分离与缓存详解
2401_85000826的博客
07-08 466
通过精细配置Nginx的动静分离与缓存策略，可以极大提升网站的性能，为用户提供更快、更流畅的访问体验。记住，优化是一个持续的过程，随着网站流量的变化和业务需求的演进，适时调整配置参数，以达到最佳效果。
电脑 DNS 缓存是什么？如何清除？
qq_57728300的博客
07-11 443
本文告诉你 DNS 缓存是什么，并教会你如何使用命令将其清除。
什么是强缓存和协商缓存
2301_76352996的博客
07-10 474
如果两个文件指纹不吻合，则说明文件被更改，那么将新的文件指纹重新存储到响应头的ETag中并返回给客户端。强缓存和协商缓存是HTTP缓存机制的两种类型，它们用于减少服务器的负担和提高网页加载速度。如果比对的结果说资源已经更新了，就会给浏览器正常返回资源，返回200状态。：客户端在没有向服务器发送请求的情况下，直接从本地缓存中获取资源。值，如果比对的结果是没有变化，表示资源未发生变化，返回状态码。值，如果匹配，表示资源未发生变化，返回状态码。强缓存失效时，浏览器会发送请求到服务器，通过。
Redis入门必学操作手册
12-11
而Redis提供了跨实例的一致性，所有实例共享同一份缓存数据，适合需要高一致性的大型分布式系统。尽管维护Redis服务的高可用性会增加系统复杂度，但其强大的功能和良好的社区支持使其成为首选。 Redis与Memcached...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ThatMonth

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值