Redis（击穿、穿透、雪崩）

缓存击穿

问题描述：客户端在服务端访问热点数据，服务端访问缓存数据，而缓存数据并不存在，或者已经过期。导致大量的客户端去访问了MySQL数据库。

图1【缓存击穿】

解决方案：

  1. 互斥锁：使用了redis中的setnx方法实现了互斥锁，只允许一条线程去访问数据库，并把数据带出，再次刷新redis中的数据。

    图2【缓存击穿-互斥锁】
    思路描述： 
    //1. 访问redis，查询数据
//2. 数据存在，则返回成功
//3. 数据不存在
//3.1 使用setnx获取redis锁
//4. 获取成功，
//4.1 访问数据库，获取信息，存入redis中，释放锁
//5. 获取失败，重复调用该方法

    Java代码实现互斥锁

    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);
}

    实际案例：

    public Shop queryWithMutex(Long id)  {
       String key = CACHE_SHOP_KEY + id;
       // 1、从redis中查询商铺缓存
       String shopJson = stringRedisTemplate.opsForValue().get("key");
       // 2、判断是否存在
       if (StrUtil.isNotBlank(shopJson)) {
           // 存在,直接返回
           return JSONUtil.toBean(shopJson, Shop.class);
       }
       //判断命中的值是否是空值
       if (shopJson != null) {
           //返回一个错误信息
           return null;
       }
       // 4.实现缓存重构
       //4.1 获取互斥锁
       String lockKey = "lock:shop:" + id;
       Shop shop = null;
       try {
           boolean isLock = tryLock(lockKey);
           // 4.2 判断否获取成功
           if(!isLock){
               //4.3 失败，则休眠重试
               Thread.sleep(50);
               return queryWithMutex(id);
           }
           //4.4 成功，根据id查询数据库
            shop = getById(id);
           // 5.不存在，返回错误
           if(shop == null){
                //将空值写入redis
               stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
               //返回错误信息
               return null;
           }
           //6.写入redis
           stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_NULL_TTL,TimeUnit.MINUTES);

       }catch (Exception e){
           throw new RuntimeException(e);
       }
       finally {
           //7.释放互斥锁
           unlock(lockKey);
       }
       return shop;
 }

  2. 逻辑过期：此处的过期时间并不是redis的ttl过期时间，而是我们自己构造的数据结构中的过期时间，用于存入redis中。

    @Data
public class RedisData {
    private LocalDateTime expireTime; //过期时间
    private Object data; //存入数据
}

    图3【缓存击穿-逻辑过期】

    思路描述：

    // 1.根据id获取redis数据
// 2.获取到的redis数据，判断过期
// 3.如果过期，则创建子线程进行刷新redis数据
// 4.没有过期，正常返回数据

    Java代码示例

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public Shop queryWithLogicalExpire( Long id ) {
    String key = CACHE_SHOP_KEY + 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);
    Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
    LocalDateTime expireTime = redisData.getExpireTime();
    // 5.判断是否过期
    if(expireTime.isAfter(LocalDateTime.now())) {
        // 5.1.未过期，直接返回店铺信息
        return shop;
    }
    // 5.2.已过期，需要缓存重建
    // 6.缓存重建
    // 6.1.获取互斥锁
    String lockKey = LOCK_SHOP_KEY + id;
    boolean isLock = tryLock(lockKey);
    // 6.2.判断是否获取锁成功
    if (isLock){
        CACHE_REBUILD_EXECUTOR.submit( ()->{

            try{
                //重建缓存
                this.saveRedisData(id,20L);
            }catch (Exception e){
                throw new RuntimeException(e);
            }finally {
                unlock(lockKey);
            }
        });
    }
    // 6.4.返回过期的商铺信息
    return shop;
}
public void saveRedisData(Long id, Long expireSeconds) {
    Shop shop = getById(id);
    RedisData redisData = new RedisData();
    redisData.setData(shop);
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
    redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
}

缓存穿透

问题描述：客户端访问redis，数据不存在，然后就去直接访问MySQL数据库也不存在。压力给到了我们的MySQL。这就是彻彻底底的透彻。

图4【缓存穿透】

解决方案：

  1. 缓存null对象：若该数据从数据库中查到的也是null，为了防止再次访问数据库我们可以使用setnx+缓存该key,value为null

    图5【缓存穿透-缓存null】

    思路描述：

    //1. 判断数据是否在Redis中
//2. 获取锁，判断数据是否在数据库中（若获取不到锁则重复调用该方法）
//2.1 不存在，则在redis中创建
//3. 释放锁

  2. 布隆过滤器：布隆过滤器其实采用的是哈希思想来解决这个问题，通过一个庞大的二进制数组，走哈希思想去判断当前这个要查询的这个数据是否存在，如果布隆过滤器判断存在，则放行，这个请求会去访问redis，哪怕此时redis中的数据过期了，但是数据库中一定存在这个数据，在数据库中查询出来这个数据后，再将其放入到redis中，

    假设布隆过滤器判断这个数据不存在，则直接返回

    这种方式优点在于节约内存空间，存在误判，误判原因在于：布隆过滤器走的是哈希思想，只要哈希思想，就可能存在哈希冲突

缓存雪崩

问题描述：客户端在服务端访问大量的热点数据，服务端访问缓存数据，而缓存数据并不存在，或者已经过期。导致大量的客户端去访问了MySQL数据库，最终容易导致数据库服务器宕机。

解决办法：

  1. 缓存数据过期时间随机化
    将缓存数据的过期时间进行随机分布，避免大量数据同时过期而导致同时请求后端存储系统。例如，可以在设置缓存时加入一个随机的过期时间，分散缓存失效的时间点。

    // 示例：随机设置缓存过期时间
Random random = new Random();
int expireTime = 600 + random.nextInt(600); // 设置一个10到20分钟的随机过期时间
redisTemplate.opsForValue().set(cacheKey, cachedValue, expireTime, TimeUnit.SECONDS);

  2. 互斥锁解决每个过期key的问题
    在缓存失效时，通过加锁或者分布式锁的方式，保证只有一个请求去更新缓存，其他请求等待新缓存的生成。这样可以有效避免大量请求同时击穿缓存。

    // 示例：使用分布式锁更新缓存
String lockKey = "cache_lock:" + cacheKey;
boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "locked", lockExpireTime, TimeUnit.SECONDS);
try {
    if (locked) {
        // 查询数据库或其他服务获取最新数据，并更新缓存
        Object newValue = fetchDataFromDatabase(key);
        redisTemplate.opsForValue().set(cacheKey, newValue, expireTime, TimeUnit.SECONDS);
    } else {
        // 未获取到锁，等待一段时间后重试
        Thread.sleep(100);
        // 递归或其他重试机制
    }
} finally {
    if (locked) {
        redisTemplate.delete(lockKey); // 释放锁
    }
}
posted @   DAawson  阅读(31)  评论(0)  编辑  收藏  举报
相关博文：
· RabbitMQ可靠性机制
· Promise、async、await
· Redis 缓存击穿问题
· redis实战-商城系统
· 重学Redis解决方案（五）—— 缓存击穿问题及解决思路及封装工具类
阅读排行：
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· Docker 太简单，K8s 太复杂？w7panel 让容器管理更轻松！
点击右上角即可分享
微信分享提示