Redis-更新策略,缓存穿透,缓存雪崩,缓存击穿

1.缓存更新策略

淘汰策略
超时剔除
主动更新
1. 更新策略：先修改数据库还是先删除缓存结论：先修改数据库，因为缓存的操作比较快，容易产生数据不一致
2. 更新缓存还是删除缓存？

2.缓存穿透

客户端请求的数据在缓存和数据库中都不存在，这些请求会访问到数据库

解决方式

缓存空值：额外内存空间；短期造成数据不一致
布隆过滤器，把数据转换成二进制的情况存储，即使在布隆过滤其中存在，实际上也可能不存在，因此有一定的风险
增加id复杂度，主动预防缓存穿透情况
增强用户的权限

3.缓存雪崩

是指在同一时间大量的缓存失效或redis服务器宕机，导致大量的请求同时访问数据库。

解决方式：

设置缓存key随机的TTL
增加redis服务高可用
大量的请求限流
多级缓存，nginx，jvm，浏览器等
设置热点数据不过期

4.缓存击穿

缓存击穿也叫热点Key问题，一个被高并发访问并且缓存业务重建复杂的key失效了，导致大量的key访问数据库带来冲击。

解决方式：

互斥锁
逻辑过期

在这里插入图片描述

热点数永不过期
限流熔断

缓存击穿-互斥锁代码实现：

 /** 缓存数据KEY */
    private final String CACHE_SHOP_KEY = "CACHE_SHOP_KEY:";
    /** 缓存互斥锁KEY */
    private final String CACHE_SHOP_LOCK_KEY = "CACHE_SHOP_LOCK_KEY:";

    @Autowired
    private StringRedisTemplate stringRedisTemplate;




/**
     * redis缓存
     * 缓存击穿-互斥锁版本
     * @param bookId
     */
    private BooksVo tryCacheMutex(Long bookId) {
        // RedisKey
        String cacheKey = CACHE_SHOP_KEY + bookId;
        // 1.从Redis查询商铺缓存
        // 获取缓存数据
        String contentBook = stringRedisTemplate.opsForValue().get(cacheKey);
        // 2.判断缓存是否命中
        if (StringUtils.isNotBlank(contentBook)){
            // 3.1缓存命中 直接返回结果
            return JSONUtil.toBean(contentBook, BooksVo.class);
        }
        BooksVo booksVo = null;
        try {
            // 3.2缓存未命中,尝试获取互斥锁
            if (BooleanUtil.isFalse(tryLock(bookId))) {
                // 4.1获取互斥锁失败,尝试重试
                Thread.sleep(50);
                return tryCacheMutex(bookId);
            }
            // 4.2 获取互斥锁成功
            // 4.3 再次检测缓存是存在 doubleCheck
            contentBook = stringRedisTemplate.opsForValue().get(cacheKey);
            if (StringUtils.isNotBlank(contentBook)){
                return JSONUtil.toBean(contentBook, BooksVo.class);
            }
            // 4.4 查询数据库,缓存重建
            booksVo = this.queryById(bookId);
            // 模拟缓存重建延迟
            Thread.sleep(200);
            String jsonBook = JSONUtil.toJsonStr(booksVo);
            stringRedisTemplate.opsForValue().set(cacheKey,jsonBook);
        } catch (InterruptedException e) {
            throw new RuntimeException();
        }finally {
            // 5.释放锁
            stringRedisTemplate.delete(CACHE_SHOP_LOCK_KEY + bookId);
        }

        return booksVo;
    }

    /**
     * 获取互斥锁
     */
    public boolean tryLock(Long bookId){
        // redis: set xxx value nx ex 10 添加锁nx是互斥，ex设置过期时间
        Boolean aBoolean = stringRedisTemplate.opsForValue()
            .setIfAbsent(CACHE_SHOP_LOCK_KEY + bookId, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(aBoolean);
    }

后期更新逻辑过期的实现方式

========20240209

更新一波工具类完成互斥锁操作

@Slf4j
@Component
@AllArgsConstructor
public class PikerRedisUtils {

    private final StringRedisTemplate stringRedisTemplate;


    /**
     * 存储String值,设置TTL
     */
    private void set(String key, Object value, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    }

    /**
     * 存储逻辑过期时间
     */
    private void setExpiration(String key, Object value, Long time, TimeUnit unit){
        // 封装过期时间
        RedisData redisData = new RedisData();
        redisData.setData(JSONUtil.toJsonStr(value));
        redisData.setExpireSecond(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    /**
     * <R, ID> 用于指定此方法所处理的泛型类型：
     *   - R：代表方法返回的结果类型，即从缓存或数据库中获取的具体业务对象类型。
     *   - ID：标识要查询的特定资源的唯一标识符类型，通常为某种主键或唯一键。

     * 方法功能：
     *   实现缓存击穿防护机制，结合互斥锁（Mutex）避免大量并发请求直接穿透缓存到达数据库，
     *   造成数据库压力过大。适用于高并发场景下对同一资源（由 `ID` 标识）的频繁访问。

     * 参数说明：
     *   - `key`：用于构造缓存键的基础部分，与 `id` 结合形成完整的缓存键。
     *   - `id`：指定要查询资源的唯一标识符，用于从缓存或数据库中定位具体数据。
     *   - `tClass`：`Class<R>` 类型参数，表示期望从缓存或数据库中获取数据的类类型，用于反序列化 JSON 数据。
     *   - `time`：表示在尝试获取互斥锁时愿意等待的最大时间量。
     *   - `unit`：时间单位，与 `time` 结合确定等待锁的实际时长。
     *   - `lockKey`：互斥锁的键名，在 Redis 中用于实现分布式锁。
     *   - `dbFallback`：`Function<ID, R>` 类型参数，提供一个回调函数，当缓存未命中时，用于查询数据库并返回 `R` 类型数据。

     * 方法逻辑：
     *   1. 构建基于 `key` 和 `id` 的 Redis 缓存键。
     *   2. 尝试从 Redis 中获取缓存数据。
     3. 若缓存命中，则直接反序列化并返回缓存中的数据。
     4. 若缓存未命中：
     a. 尝试获取互斥锁，若获取失败则短暂休眠后递归调用自身重试。
     b. 若成功获取互斥锁，进行双重检查以确认缓存是否在等待锁期间已被其他线程填充。
     c. 若缓存仍为空，则调用 `dbFallback` 函数查询数据库，获取 `R` 类型数据。
     d. 将数据库查询结果转化为 JSON 存储至 Redis，完成缓存重建。
     e. 最后释放互斥锁，确保资源的正确释放。

     * 返回值：
     *   返回与给定 `id` 对应的 `R` 类型数据，该数据来源于缓存（优先）或数据库查询（缓存未命中时）。
     *
     */
    public <R,ID> R getMutex(String key, ID id, Class<R> tClass, Long time,
                             TimeUnit unit, String lockKey, Function<ID, R> dbFallback){
        // RedisKey
        String cacheKey = key + id;
        // 1.从Redis查询商铺缓存
        // 获取缓存数据
        String contentBook = stringRedisTemplate.opsForValue().get(cacheKey);
        // 2.判断缓存是否命中
        if (StringUtils.isNotBlank(contentBook)){
            // 3.1缓存命中 直接返回结果
            return JSONUtil.toBean(contentBook, tClass);
        }
        R r = null;
        try {
            // 3.2缓存未命中,尝试获取互斥锁
            if (BooleanUtil.isFalse(tryLock(lockKey, time ,unit))) {
                // 4.1获取互斥锁失败,尝试重试
                Thread.sleep(50);
                return getMutex(key, id, tClass, time, unit, lockKey, dbFallback);
            }
            // 4.2 获取互斥锁成功
            // 4.3 再次检测缓存是存在 doubleCheck
            contentBook = stringRedisTemplate.opsForValue().get(cacheKey);
            if (StringUtils.isNotBlank(contentBook)){
                return JSONUtil.toBean(contentBook, tClass);
            }
            // 4.4 查询数据库,缓存重建
            r = dbFallback.apply(id);
            // 模拟缓存重建延迟
            // Thread.sleep(200);
            String jsonBook = JSONUtil.toJsonStr(r);
            stringRedisTemplate.opsForValue().set(cacheKey,jsonBook);
        } catch (InterruptedException e) {
            throw new RuntimeException();
        }finally {
            // 5.释放锁
            stringRedisTemplate.delete(lockKey);
        }

        return r;
    }
    
    
    /**
     * 获取互斥锁
     */
    public boolean tryLock(String lockKey,Long time,  TimeUnit unit){
        // redis: set xxx value nx ex 10 添加锁nx是互斥，ex设置过期时间
        Boolean aBoolean = stringRedisTemplate.opsForValue()
            .setIfAbsent(lockKey, "1", time, unit);
        return BooleanUtil.isTrue(aBoolean);
    }

调用

@Override
    public BooksVo selectById(Long bookId) {
        // 缓存击穿-工具类-互斥锁
        return pikerRedisUtils.getMutex(CACHE_SHOP_KEY,bookId,BooksVo.class, 10L,
            TimeUnit.SECONDS, CACHE_SHOP_LOCK_KEY+bookId,item -> baseMapper.selectVoById(bookId));

        // 缓存击穿-互斥锁
        // return tryCacheMutex(bookId);

        // 缓存击穿-逻辑过期时间
        // return tryCacheMutex2(bookId);

    }