引言

缓存击穿：给某一个key设置了过期时间，当key过期的时候，恰好这个时间点对这个key有大量的并发请求过来，这些并发的请求可能会瞬间把DB压垮

解决办法


互斥锁（强一致，性能差）

根据图片就可以看出，我们的思路就是只能让一个线程能够进行访问Redis，要想实现这个功能，我们也可以使用Redis自带的setnx
封装两个方法，一个写key来尝试获取锁另一个删key来释放锁

1. /**
   
2. * 尝试获取锁
   
3. *
   
4. * @param key
   
5. * @return
   
6. */
   
7. private boolean tryLock(String key) {
   
8.     Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
   
9.     return BooleanUtil.isTrue(flag);
   
10. }
    
11. 
    
12. /**
    
13. * 释放锁
    
14. *
    
15. * @param key
    
16. */
    
17. private void unlock(String key) {
    
18.     stringRedisTemplate.delete(key);
    
19. }

复制代码

在并行情况下每当其他线程想要获取锁，来访问缓存都要通过将自己的key写到tryLock（）方法里，setIfAbsent（）返回false则说明有线程在在更新缓存数据，锁未释放。若返回true则说明当前线程拿到锁了可以访问缓存甚至操作缓存。
我们在下面一个热门的查询场景中用代码用代码来实现互斥锁解决缓存击穿，代码如下：

1.     /**
   
2.      * 解决缓存击穿的互斥锁
   
3.      * @param id
   
4.      * @return
   
5.      */
   
6.     public Shop queryWithMutex(Long id) {
   
7.         String key = CACHE_SHOP_KEY + id;
   
8.         //1.从Redis查询缓存
   
9.         String shopJson = stringRedisTemplate.opsForValue().get(key);  //JSON格式
   
10.         //2.判断是否存在
    
11.         if (StrUtil.isNotBlank(shopJson)) { //不为空就返回 此工具类API会判断" "为false
    
12.             //存在则直接返回
    
13.             Shop shop = JSONUtil.toBean(shopJson, Shop.class);
    
14.             //return Result.ok(shop);
    
15.             return shop;
    
16.         }
    
17.         //3.判断是否为空值 这里过滤 " "的情况，不用担心会一直触发这个条件因为他有TTL
    
18.         if (shopJson != null) {
    
19.             //返回一个空值
    
20.             return null;
    
21.         }
    
22.         //4.缓存重建 Redis中值为null的情况
    
23.         //4.1获得互斥锁
    
24.         String lockKey = "lock:shop"+id;
    
25.         Shop shopById=null;
    
26.         try {
    
27.             boolean isLock = tryLock(lockKey);
    
28.             //4.2判断是否获取成功
    
29.             if (!isLock){
    
30.                 //4.3失败，则休眠并重试
    
31.                 Thread.sleep(50);
    
32.                return queryWithMutex(id);
    
33.             }
    
34.             //4.4成功，根据id查询数据库
    
35.             shopById = getById(id);
    
36.             //5.不存在则返回错误
    
37.             if (shopById == null) {
    
38.                 //将空值写入Redis
    
39.                 stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
    
40.                 //为什么这里要存一个" "这是因为如果后续DB中有数据补充的话还可以去重建缓存
    
41.                 //return Result.fail("暂无该商铺信息");
    
42.                 return null;
    
43.             }
    
44.             //6.存在，写入Redis
    
45.             stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shopById), CACHE_SHOP_TTL, TimeUnit.MINUTES);
    
46.         } catch (InterruptedException e) {
    
47.             throw new RuntimeException(e);
    
48.         } finally {
    
49.             //7.释放互斥锁
    
50.             unlock(lockKey);
    
51.         }
    
52. 
    
53.         return shopById;
    
54.     }

复制代码

逻辑过期（高可用，性能优）

方案：用户查询某个热门产品信息，如果缓存未命中(即信息为空)，则直接返回空，不去查询数据库。如果缓存信息命中，则判断是否逻辑过期，未过期返回缓存信息，过期则重建缓存，尝试获得互斥锁，获取失败则直接返回已过期缓存数据，获取成功则开启独立线程去重构缓存然后直接返回旧的缓存信息，重构完成之后就释放互斥锁。

封装一个方法用来模拟更新逻辑过期时间与缓存的数据在测试类里运行起来达到数据与热的效果

1. /**
   
2. * 添加逻辑过期时间
   
3. *
   
4. * @param id
   
5. * @param expireTime
   
6. */
   
7. public void saveShopRedis(Long id, Long expireTime) {
   
8.     //查询店铺信息
   
9.     Shop shop = getById(id);
   
10.     //封装逻辑过期时间
    
11.     RedisData redisData = new RedisData();
    
12.     redisData.setData(shop);
    
13.     redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireTime));
    
14.     //将封装过期时间和商铺数据的对象写入Redis
    
15.     stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
    
16. }

复制代码

查询接口：

1. /**
   
2. * 逻辑过期解决缓存击穿
   
3. *
   
4. * @param id
   
5. * @return
   
6. */
   
7. public Shop queryWithLogicalExpire(Long id) throws InterruptedException {
   
8.     String key = CACHE_SHOP_KEY + id;
   
9.     Thread.sleep(200);
   
10.     //1.从Redis查询缓存
    
11.     String shopJson = stringRedisTemplate.opsForValue().get(key);  //JSON格式
    
12.     //2.判断是否存在
    
13.     if (StrUtil.isBlank(shopJson)) {
    
14.         //不存在则直接返回
    
15.         return null;
    
16.     }
    
17.     //3.判断是否为空值
    
18.     if (shopJson != null) {
    
19.         //返回一个空值
    
20.         //return Result.fail("店铺不存在！");
    
21.         return null;
    
22.     }
    
23.     //4.命中
    
24.     //4.1将JSON反序列化为对象
    
25.     RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
    
26.     Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
    
27.     LocalDateTime expireTime = redisData.getExpireTime();
    
28.     //4.2判断是否过期
    
29.     if (expireTime.isAfter(LocalDateTime.now())) {
    
30.         //5.未过期则返回店铺信息
    
31.         return shop;
    
32.     }
    
33.     //6.过期则缓存重建
    
34.     //6.1获取互斥锁
    
35.     String LockKey = LOCK_SHOP_KEY + id;
    
36.     boolean isLock = tryLock(LockKey);
    
37.     //6.2判断是否成功获得锁
    
38.     if (isLock) {
    
39.         //6.3成功，开启独立线程，实现缓存重建
    
40.         CACHE_REBUILD_EXECUTOR.submit(() -> {
    
41.             try {
    
42.                 //重建缓存
    
43.                 this.saveShop2Redis(id, 20L);
    
44. 
    
45.             } catch (Exception e) {
    
46.                 throw new RuntimeException(e);
    
47.             } finally {
    
48.                 //释放锁
    
49.                 unlock(LockKey);
    
50.             }
    
51.         });
    
52.     }
    
53.     //6.4返回商铺信息
    
54.     return shop;
    
55. }

复制代码

设计逻辑过期时间

可以用这个方法设置逻辑过期时间

1. import org.redisson.Redisson;
   
2. import org.redisson.api.RBucket;
   
3. import org.redisson.api.RedissonClient;
   
4. import org.redisson.config.Config;
   
5. 
   
6. public class RedissonExample {
   
7.     public static void main(String[] args) {
   
8.         Config config = new Config();
   
9.         config.useSingleServer().setAddress("redis://127.0.0.1:6379");
   
10. 
    
11.         RedissonClient redisson = Redisson.create(config);
    
12. 
    
13.         String key = "exampleKey";
    
14.         String value = "exampleValue";
    
15.         int timeout = 10; // 过期时间（秒）
    
16. 
    
17.         // 获取RBucket对象
    
18.         RBucket<String> bucket = redisson.getBucket(key);
    
19. 
    
20.         // 设置值并指定过期时间
    
21.         bucket.set(value, timeout, TimeUnit.SECONDS);
    
22. 
    
23.         System.out.println("设置成功");
    
24.         redisson.shutdown();
    
25.     }
    
26. }

复制代码

大家可以看到，逻辑过期锁就是可以实现并发，所以他的效率更快，性能更好
但是

• 牺牲了数据的实时性，以保证高并发场景下的服务可用性和数据库的稳定性。
  
• 在实际应用中，需要确保获取互斥锁的操作是原子的，并且锁具有合适的超时时间，以避免死锁的发生。
  
• 逻辑过期策略适用于那些对数据实时性要求不高，但要求服务高可用性的场景。
  

到此这篇关于Redis解决缓存击穿问题的两种方法的文章就介绍到这了,更多相关Redis解决缓存击穿内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：https://www.jb51.net/database/3381779y3.htm
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！