Redis 缓存击穿问题及解决方法

2023-08-24

字数统计: 2.7k字 | 阅读时长: 11分

缓存击穿有相似之处，都是直接绕过Redis缓存去访问数据库，但是场景不一样。缓存击穿应用的场景主要是热点数据或者被频繁访问的数据。缓存击穿指的是某个热点数据过期或者被删除，导致大量请求直接绕过缓存去访问数据库，导致数据库压力瞬间升高，甚至崩溃。解决缓存击穿这个问题，可以使用互斥锁或者分布式的方式，保证同一时间里面，只有一个线程去查询和重建缓存。

下面是模拟两个线程在争夺互斥锁的场景，在同一台服务器下，当线程1拿到互斥锁后，JVM内部的锁监视器就会检测到有线程在运行，其他线程就不能执行了。等到线程1查询数据且重建完缓存后，就会去释放锁。一旦线程1释放锁，线程2就可以拿到互斥锁，接着查询缓存发现已经存在，就会直接返回数据并且释放锁。这样就可以解决在单体服务器下，缓存击穿的问题。（集群服务器使用分布式锁）

166574832

1、使用互斥锁（Mutex）：

在缓存失效或者被删除的瞬间，使用互斥锁进行资源控制，只允许一个请求进入数据库查询，其他请求等待。这样可以避免大量请求同时查询数据库，从而导致数据库崩溃。

这里利用Redis命令setnx唯一性的特性来做互斥锁，只有创建锁成功，才能执行下面的操作，否则就只能等待重试。这个方法是实现简单，保证一致性，且维护方便。缺点是只能在单体服务器下有效运行。

public Result QueryRedisById(Long id) {
       // 互斥锁解决缓冲击穿
       Shop shop = queryWithMutex(id);

       // 店铺不存在
       if (shop == null) {
           return Result.fail("商铺不存在！");
       }
       // 返回商铺信息
       return Result.ok(shop);
   }
public Shop queryWithMutex(Long id) {
       String key = RedisConstants.CACHE_SHOP_KEY + id;
       // 1. 根据提交的 id 从 Redis 中查询商铺缓存信息(可以直接操作Hash，就不用转换Json了)
       String shopMsg = stringRedisTemplate.opsForValue().get(key);
       // 2. 判断缓存中是否存在商铺信息
       if (StrUtil.isNotBlank(shopMsg)) {
           // 3. 存在，则返回商铺信息
           return JSONUtil.toBean(shopMsg, Shop.class);
       }
       // 判断是否命中空值
       if (shopMsg != null) {    // 等价于 shopMsg == ""，上面已经判断过 null 的情况
           // 放行，让缓存击穿优化
           return null;
       }
       // 4. 缓存未命中
       // 4.1 实现缓存重建，获取互斥锁
       // 商铺的互斥锁 key
       String mutexKey = LOCK_SHOP_KEY + id;
       Shop shop = null;
       try {
           // 4.2 判断是否获取锁成功
           boolean flag = tryLock(mutexKey);
           while (!flag) {
               // 4.3 获取锁失败，等待一会继续重试
               Thread.sleep(50);
               flag = tryLock(mutexKey);
           }
           // 4.4 拿到互斥锁后，再次判断是否有别的线程已经把缓存写入
           String ObjJson = stringRedisTemplate.opsForValue().get(key);
           // 4.5 判断缓存中是否存在信息
           if (StrUtil.isNotBlank(ObjJson)) {
               // 4.6 存在，则返回商铺信息
               return JSONUtil.toBean(ObjJson, type);
           }
           /*if (!flag) {  // 可以用递归替代前面的代码，但是用递归不好，所以选用循环了
               // 4.3 获取锁失败，等待一会继续重试
               Thread.sleep(50);
               return queryWithMutex(id);
           }*/
           // 4.7. 不存在，根据id查询数据库
           shop = getById(id);
           // 测试： 模拟一下重建缓存延时情况，考察功能的可靠性
           //Thread.sleep(200);
           // 5. 商铺不存在，返回错误码404
           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_SHOP_TTL, TimeUnit.MINUTES);
       } catch (InterruptedException e) {
           // 抛出异常
           throw new RuntimeException(e);
       } finally {
           // 7. 释放互斥锁
           unlock(mutexKey);
       }
       // 8. 返回商铺信息
       return shop;
   }

   /**
    * 获取互斥锁
    *
    * @param mutexKey 店铺key
    * @return 是否获取成功
    */
   private boolean tryLock(String mutexKey) {
       if (stringRedisTemplate.opsForValue().get(mutexKey) != null){
           return false;
       }
       Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(mutexKey, "mutex", LOCK_SHOP_TTL, TimeUnit.SECONDS);
       return BooleanUtil.isTrue(flag);
   }
   /**
    * 释放互斥锁
    *
    * @param mutexKey 店铺key
    */
   private void unlock(String mutexKey) {
       stringRedisTemplate.delete(mutexKey);
   }

Redis命令setnx如果key不存在才能被设置，这个就像一把互斥锁，等到获取到新的数据并且返回数据后，就删除这把锁del，可以利用这一特性来实现这个功能；但是这个程序或者代码块有可能会出现错误导致锁无法被释放（即删除），那么在设置锁的时候，根据业务执行的耗时，给它加一个TTL，如10s过期时间来自动释放锁，防止死锁。

CACHE_SHOP_KEY，CACHE_SHOP_TTL，CACHE_NULL_TTL、LOCK_SHOP_TTL这些自定义常量都是自己维护的，防止在其他地方引用出错而导致出现其他的问题。

2、使分布式锁：

这里引入Redisson来做分布式锁，实现较上一个稍复杂且集群服务器下也有效。

pom文件导入依赖：

<!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
<dependency>
     <groupId>org.redisson</groupId>
     <artifactId>redisson</artifactId>
     <version>3.19.0</version>
</dependency>

创建一个配置文件，注入Bean，交由Spring来管理。

@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient(){
        // 配置类duo
        Config config = new Config();
        // 创建RedissonClient对象。
        config.useSingleServer().setAddress("redis://127.0.0.1:6379")
        	  		.setPassword("root");
        // 返回配置类
        return Redisson.create(config);
    }
}

useSingleServer：单体Redis服务器，使用集群可以使用useClusterServers方法，或者多注入几个单体RedissonClient来组成集群。

   private final StringRedisTemplate stringRedisTemplate;

   public CacheClient(StringRedisTemplate stringRedisTemplate) {
       this.stringRedisTemplate = stringRedisTemplate;
   }
   public Result QueryRedisById(Long id) {
       // 分布式锁解决缓冲击穿
       Shop shop = queryWithMutex(id);

       // 店铺不存在
       if (shop == null) {
           return Result.fail("商铺不存在！");
       }
       // 返回商铺信息
       return Result.ok(shop);
   }
public Shop queryWithMutex(Long id) {
       String key = CACHE_SHOP_KEY + id;
       // 1. 根据提交的 id 从 Redis 中查询商铺缓存信息(可以直接操作Hash，就不用转换Json了)
       String json = stringRedisTemplate.opsForValue().get(key);
       // 2. 判断缓存中是否存在商铺信息
       if (StrUtil.isNotBlank(json)) {
           // 3. 存在，则返回商铺信息
           return JSONUtil.toBean(json, Shop.class);
       }
       // 判断是否命中空值
       if (json != null) {    // 等价于 json == ""，上面已经判断过 null 的情况
           // 放行，让缓存击穿优化
           return null;
       }
       // 4. 缓存未命中
       // 4.1 实现缓存重建，获取分布式锁
       // 分布式锁的 key
       String mutexKey = LOCK_SHOP_KEY + id;
       RLock lock = redissonClient.getLock(mutexKey);
       Shop shop = null;
       try {
           // 4.2 判断是否获取锁成功
           boolean flag = lock.tryLock();
           while (!flag) {
               // 4.3 获取锁失败，等待一会继续重试
               Thread.sleep(50);
               flag = lock.tryLock();
           }
           // 4.4 拿到分布式锁后，再次判断是否有别的线程已经把缓存写入
           String ObjJson = stringRedisTemplate.opsForValue().get(key);
           // 4.5 判断缓存中是否存在商铺信息
           if (StrUtil.isNotBlank(ObjJson)) {
               // 4.6 存在，则返回商铺信息
               return JSONUtil.toBean(ObjJson, Shop.class);
           }
           /*if (!flag) {  // 可以用递归替代前面的代码，但是用递归不好，所以选用循环了
               // 4.3 获取锁失败，等待一会继续重试
               Thread.sleep(50);
               return queryWithMutex(id);
           }*/
           // 4.7. 不存在，根据id查询数据库
           shop = getById(id);
           // 测试： 模拟一下重建缓存延时情况，考察功能的可靠性
           //Thread.sleep(200);
           // 5. 商铺不存在，返回错误码404
           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_SHOP_TTL, TimeUnit.MINUTES);
       } catch (InterruptedException e) {
           // 抛出异常
           throw new RuntimeException(e);
       } finally {
           // 7. 释放分布式锁
           lock.unlock();
       }
       // 8. 返回商铺信息
       return shop;
   }

逻辑与使用Redis命令的setnx的方法基本一致，只是省去了自定义的步骤，且在集群服务器也可生效。

3、基于逻辑过期解决缓存击穿：

这个方法的优点是无需线程等待，就可以直接获取。缺点也较为明显，不能保证一致性，会有额外的内存消耗，且实现复杂。

@Override
   public Result QueryRedisById(Long id) {
       // 基于逻辑过期解决缓存击穿问题
       Shop shop = queryWithLogicalExpire(id);
       // 店铺不存在
       if (shop == null) {
           return Result.fail("商铺不存在！");
       }
       // 返回商铺信息
       return Result.ok(shop);
   }
   private ExecutorService poolExecutor = Executors.newSingleThreadExecutor();
public Shop queryWithLogicalExpire(Long id) {
       String key = RedisConstants.CACHE_SHOP_KEY + id;
       // 1. 根据提交的 id 从 Redis 中查询商铺缓存信息(可以直接操作Hash，就不用转换Json了)
       String shopMsg = stringRedisTemplate.opsForValue().get(key);
       // 2. 判断缓存中是否存在商铺信息
       if (StrUtil.isBlank(shopMsg)) {
           // 3. 未命中。不存在，则返回空值
           return null;
       }
       // 4. 缓存命中，把json反序列化成对象
       RedisData redisData = JSONUtil.toBean(shopMsg, RedisData.class);
       Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
       // 4.1 判断缓存是否过期
       if (redisData.getExpireTime().isAfter(LocalDateTime.now())) {
           // 5. 缓存未过期，返回店铺信息
           return shop;
       }
       // 6. 缓存过期，尝试获取互斥锁
       String mutexKey = LOCK_SHOP_KEY + id;
       boolean isLock = tryLock(mutexKey);
       // 6.1 获取锁成功，开启独立线程，实现缓存重建
       if (isLock){
           poolExecutor.submit(() ->{
               try {
                   // 6.2 把查询的商铺信息写到 Redis，并设置逻辑过期时间
                   saveShop2Redis(id, 30L);
               } catch (Exception e) {
                   throw new RuntimeException(e);
               } finally {
                   // 7. 释放互斥锁
                   unlock(mutexKey);
               }
           });
       }
       // 8. 返回商铺信息
       return shop;
   }
   // 存储redis本地热点数据
   public void saveShop2Redis(Long id, Long expireSeconds) throws InterruptedException {
       // 1. 查询数据库店铺信息
       Shop shop = getById(id);
       // 模拟数据重建需要的时间
       Thread.sleep(200);
       // 2. 把店铺信息封装成 redisData 对象
       RedisData redisData = new RedisData();
       redisData.setData(shop);
       redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
       // 3. 把redisData存储到redis服务器
       stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
   }
   private boolean tryLock(String mutexKey) {
       Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(mutexKey, "mutex", LOCK_SHOP_TTL, TimeUnit.SECONDS);
       return BooleanUtil.isTrue(flag);
   }
   private void unlock(String mutexKey) {
       stringRedisTemplate.delete(mutexKey);
   }

@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

这个方法的思路就是，先把热点数据预加载到Redis服务器，然后这个方法会有一个逻辑过期时间expireTime存储在RedisData，等待客户端访问热点数据的时候，会直接从Redis服务器中查询数据，拿到数据后直接转换成目标对象返回，同时会判断逻辑过期时间是否已经过期，如果已经过期了，就会查询数据库并且更新数据。所以，在逻辑有效期内，如果数据发生了改变，就会导致数据不一致的问题。

这里必须注意的是，需要提前把热点数据封装成RedisData对象并存储进 Redis 服务器。

以上就是今天分享的三种关于解决缓存击穿的方法。

本文作者： Long HY
本文链接： https://longzas.github.io/2023/08/24/Redis-%E7%BC%93%E5%AD%98%E5%87%BB%E7%A9%BF%E9%97%AE%E9%A2%98%E5%8F%8A%E8%A7%A3%E5%86%B3%E6%96%B9%E6%B3%95/
版权声明： 本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。转载请注明出处！