Redis实战常用二、缓存的使用

大刀爱敲代码2025-03-23 8:07

一、什么是缓存

  1. 在实际开发中,系统需要"避震器"，防止过高的数据访问猛冲系统,导致其操作线程无法及时处理信息而瘫痪.

    • 这在实际开发中对企业讲,对产品口碑,用户评价都是致命的。所以企业非常重视缓存技术;

  2. 缓存(Cache) ：就是数据交换的缓冲区 ，俗称的缓存就是缓冲区内的数据，一般从数据库中获取，存储于本地代码中。

    • 缓冲区：是存储数据的临时地方，一般读写性能较高。
  • 例子：
java 复制代码 
// 例1:
static final ConcurrentHashMap<K,V> map = new ConcurrentHashMap<>(); //本地用于高并发缓存

// 例2:
static final Cache<K,V> USER_CACHE = CacheBuilder.newBuilder().build(); // 用于redis等缓存

// 例3:
Static final Map<K,V> map =  new HashMap(); // 本地缓存

由于其被Static 修饰,所以随着类的加载而被加载到内存之中 ，作为本地缓存，由于其又被final修饰，所以其引用(例3:map)和对象(例3:new HashMap())之间的关系是固定的，不能改变，因此不用担心赋值(=)导致缓存失效。

二、为什么使用缓存

  • 优点：访问速度快，好用
  1. 缓存数据存储于代码 中，而代码运行在内存 中，内存的读写性能远高于磁盘，缓存可以大大降低用户访问并发量带来的 服务器读写压力。
    • 实际开发过程中,企业的数据量,少则几十万,多则几千万,这么大数据量,如果没有缓存来作为"避震器",系统是几乎撑不住的,所以企业会大量运用到缓存技术。
  • 缓存也会增加代码复杂度和运营的成本。

三、使用缓存的缺点与优点

四、如何使用缓存

  1. 实际开发中,会构建多级缓存来使系统运行速度进一步提升，例如：本地缓存与redis中的缓存并发使用等等。
    • 浏览器缓存：主要是存在于浏览器端的缓存
    • 应用层缓存：可以分为tomcat本地缓存，比如之前提到的map，或者是使用redis作为缓存
    • 数据库缓存：在数据库中有一片空间是 buffer pool，增改查数据都会先加载到mysql的缓存中
    • CPU缓存 ：当代计算机最大的问题是 cpu性能提升了，但内存读写速度没有跟上，所以为了适应当下的情况，增加了cpu的L1，L2，L3级的缓存

四、1、添加缓存的思路

  • 标准的操作方式就是查询数据库之前先查询缓存：

    • 如果缓存数据存在，则直接从缓存中返回。
    • 如果缓存数据不存在，再查询数据库，然后将查询到的数据存入redis，再把数据库的数据返回。

  • 不使用缓存

  • 使用缓存

  • 举例 ：根据id查询商铺的信息

四、2、缓存的更新策略

  1. 缓存更新是redis为了节约内存而设计出来的一个东西，主要是因为内存数据宝贵，当我们向redis插入太多数据，此时就可能会导致缓存中的数据过多，所以redis会对部分数据进行更新，或者把它叫为淘汰更合适。主要有一下三种策略 ：
    • 内存淘汰：redis自动进行，当redis内存达到咱们设定的max-memery的时候，会自动触发淘汰机制，淘汰掉一些不重要的数据(可以自己设置策略方式)
    • 超时剔除：当我们给redis设置了过期时间ttl之后，redis会将超时的数据进行删除，方便后面继续使用缓存
    • 主动更新 ：我们可以手动调用方法把缓存删掉，通常用于解决缓存和数据库不一致问题

四、2.1、数据库和缓存不一致的问题解决：

  1. 由于我们的缓存的数据源来自于数据库 ,而数据库的数据是会发生变化的 ,因此,如果当数据库中数据发生变化,而缓存却没有同步 ,此时就会有一致性问题存在 ,其后果是:
    • 用户使用缓存中的过时数据,就会产生类似多线程数据安全问题，从而影响业务，产品口碑等。怎么解决呢？有如下几种方案：
      • 1、Cache Aside Pattern 人工编码方式：缓存调用者在更新完数据库后再去更新缓存，也称之为双写方案
      • 2、Read/Write Through Pattern : 由系统本身完成，数据库与缓存的问题交由系统本身去处理
      • 3、Write Behind Caching Pattern ：调用者只操作缓存，其他线程去异步处理数据库，实现最终一致

数据库和缓存不一致采用Cache Aside Pattern 人工编码方式

  • 数据库和缓存不一致采用方法为：Cache Aside Pattern 人工编码方式：缓存调用者在更新完数据库后再去更新缓存，也称之为双写方案

操作缓存和数据库时有三个问题需要考虑：

  • 假设我们每次操作数据库后，都操作缓存，但是中间如果没有人查询，那么这个更新动作实际上只有最后一次生效，中间的更新动作意义并不大，我们可以把缓存删除，等待再次查询时，将缓存中的数据加载出来.
  • 问题一：选择删除缓存还是更新缓存？ （删除缓存）
    • 更新缓存：每次更新数据库都更新缓存，无效写操作较多
    • 删除缓存：更新数据库时让缓存失效，查询时再更新缓存
  • 为什么不更新缓存儿选择直接删除缓存呢？
    • 因为缓存的更新成本比删除成本更高。（因为你写入数据库的值在很多情况下并不是直接写入缓存的，而是要经过一系列复杂的计算再写入缓存。那么每次写入数据库后都再次计算写入缓存的值，无疑是浪费性能的，所以删除缓存更为适合。
  • 问题二：如何保证缓存与数据库的操作的同时成功或失败？
    • 单体系统，将缓存与数据库操作放在一个事务
    • 分布式系统，利用TCC等分布式事务方案
  • 问题三：选择先操作缓存还是先操作数据库？ （先操作数据库，再删除缓存 ）
    • 先删除缓存，再操作数据库
    • 先操作数据库，再删除缓存
  • 具体操作缓存还是操作数据库，我们应当是先操作数据库，再删除缓存
    • 原因：如果你选择第一种方案（Cache Aside Pattern 人工编码方式），在两个线程并发来访问时，假设线程1先来，他先把缓存删了，此时线程2过来查询缓存数据并不存在，此时线程2查询数据库并把查询出来的数据写入缓存，当线程2把数据写入缓存后，线程1再执行更新动作时，实际上写入的就是旧的数据，新的数据被旧数据覆盖了。

先删除缓存还是先执行数据库操作的选择分析

  • 写缓存的时间是很快的（几毫秒），而操作数据库的时间是很长的。（操作缓存和操作数据库效率差别大）
1、先删除缓存，再操作数据
  • 先删除缓存，再操作数据的正常情况 ：
  • 先删除缓存，再操作数据的异常情况（出现数据库和缓存数据不一致的问题） ：
    • 解决办法一：延迟双删：最终一致性的方法，即使用双删的办法。（就是每次修改完数据之后再把缓存删除了（使用延迟删除，避免 删除缓存操作在旧数据的写入缓存操作 之前）），这样就保证了数据的一致性了，但还是会出现一次数据不一致的问题 ，如果想避免一次数据一致性都不出现就得使用强一致性 的方法了）（推荐使用这个方法 ）
      • 这方法感觉就相当于先操作数据库再删除缓存一样了，由此看来还是选择先操作再删除缓存
    • 解决办法二：使用强一致性的办法（就是保证redis的操作和数据库的操作的原子性），可以使用加锁的方法（使用这种方法会影响性能，我们使用redis的意义就是为了提高性能，所以加锁就得不偿失了，所以不太推荐 了）
2、 先操作数据，再删除缓存
  • 先操作数据，再删除缓存的正常情况 ：
  • 先操作数据，再删除缓存的异常情况1（出现数据库和缓存数据不一致的问题） ：因为缓存操作是很快的，所以这种异常情况几乎不可能发生。
  • 先操作数据，再删除缓存的异常情况 2：删除缓存失败的情况，就是线程2执行删除缓存操作时出现删除失败的问题，导致最终的缓存数据还是旧数据。
    • 解决方案一：使用异步删除重试的办法（结合mq）
    • 解决方案二：cannal解耦（使用cannal提供的java客户端）

最终选择：先操作数据库再删除缓存

缓存穿透

缓存雪崩

缓存击穿（热点key）

最后可以把缓存击穿和缓存穿透的解决方法封装成一个工具类

基于StringRedisTemplate封装一个缓存工具类，满足下列需求：

  • 方法1：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
  • 方法2：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓

存击穿问题

  • 方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
  • 方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
java 复制代码 
@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

//使用构造器注入第三方beanStringRedisTemplate
    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

// 添加缓存，设置key的过期时间
    public void set(String key, Object value, Long time, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    }

// 添加缓存，设置逻辑过期时间
    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
        // 设置逻辑过期
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        // 写入Redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

// 获取缓存，解决缓存穿透
    public <R,ID> R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(json)) {
            // 3.存在，直接返回
            return JSONUtil.toBean(json, type);
        }
        // 判断命中的是否是空值
        if (json != null) {
            // 返回一个错误信息
            return null;
        }

        // 4.不存在，根据id查询数据库
        R r = dbFallback.apply(id);
        // 5.不存在，返回错误
        if (r == null) {
            // 将空值写入redis
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            // 返回错误信息
            return null;
        }
        // 6.存在，写入redis
        this.set(key, r, time, unit);
        return r;
    }
    
// 使用逻辑过期时间，解决缓存击穿
    public <R, ID> R queryWithLogicalExpire(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isBlank(json)) {
            // 3.存在，直接返回
            return null;
        }
        // 4.命中，需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
        LocalDateTime expireTime = redisData.getExpireTime();
        // 5.判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())) {
            // 5.1.未过期，直接返回店铺信息
            return r;
        }
        // 5.2.已过期，需要缓存重建
        // 6.缓存重建
        // 6.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        // 6.2.判断是否获取锁成功
        if (isLock){
            // 6.3.成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 查询数据库
                    R newR = dbFallback.apply(id);
                    // 重建缓存
                    this.setWithLogicalExpire(key, newR, time, unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }finally {
                    // 释放锁
                    unlock(lockKey);
                }
            });
        }
        // 6.4.返回过期的商铺信息
        return r;
    }

// 使用互斥锁解决缓存穿透
    public <R, ID> R queryWithMutex(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 3.存在，直接返回
            return JSONUtil.toBean(shopJson, type);
        }
        // 判断命中的是否是空值
        if (shopJson != null) {
            // 返回一个错误信息
            return null;
        }

        // 4.实现缓存重建
        // 4.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        R r = null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2.判断是否获取成功
            if (!isLock) {
                // 4.3.获取锁失败，休眠并重试
                Thread.sleep(50);
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
            }
            // 4.4.获取锁成功，根据id查询数据库
            r = dbFallback.apply(id);
            // 5.不存在，返回错误
            if (r == null) {
                // 将空值写入redis
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                // 返回错误信息
                return null;
            }
            // 6.存在，写入redis
            this.set(key, r, time, unit);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            // 7.释放锁
            unlock(lockKey);
        }
        // 8.返回
        return r;
    }

    private boolean tryLock(String key) {
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }

    private void unlock(String key) {
        stringRedisTemplate.delete(key);
    }
}
相关推荐
Mapmost16 分钟前
【性能优化黑科技·数据篇】如何拿捏大数据量的矢量数据呈现？
数据库
RealmElysia29 分钟前
谷粒商城：缓存
分布式·缓存·微服务
勇敢滴勇1 小时前
Qt信号与槽高级特性与项目实战：原理剖析与工程化应用指南
网络·数据库·c++·qt·qt5·qt6.3
执墨1 小时前
啊？我的缓存中怎么出现了 java.util.ArrayList
java·redis·spring
神奇小永哥1 小时前
redis与数据库双写一致性解决方案
数据库·redis·缓存
八股文领域大手子2 小时前
同步双写与删缓存在缓存一致性的实践对比
java·redis·mysql·bootstrap·mybatis
遥不可及~~斌2 小时前
CentOS 8 安装 Redis 全流程指南：从基础部署到远程安全配置
redis·安全·centos
Floating warm sun2 小时前
Postgresql 删除数据库报错
数据库·postgresql·dba
星霜旅人2 小时前
【MySQL】从零开始：掌握MySQL数据库的核心概念（三）
数据库·mysql
xing-xing2 小时前
MySQL 字符集
数据库·mysql
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02如何在WPS和Word/Excel中直接使用DeepSeek功能03DeepSeek各版本说明与优缺点分析04LLaMA-Factory DeepSeek-R1 模型 微调基础教程05命令行方式将mysql数据库迁移到达梦数据库（全步骤）06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具08本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程09本地部署DeepSeek教程（Mac版本）10FreeCAD傻瓜教程之创建参数化几何图形-螺旋体、平面、球体、椭球体、圆柱体、圆锥体、棱柱、椭圆