Redis篇：缓存击穿及解决方案

1.何为缓存击穿

缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了（有可能是正好过期了），无数的请求访问会在瞬间给数据库带来巨大的冲击。

常见的解决方案有两种：

互斥锁
逻辑过期

逻辑分析：假设线程1在查询缓存之后，本来应该去查询数据库，然后把这个数据重新加载到缓存的，此时只要线程1走完这个逻辑，其他线程就都能从缓存中加载这些数据了，但是假设在线程1没有走完的时候，后续的线程2，线程3，线程4同时过来访问当前这个方法，那么这些线程都不能从缓存中查询到数据，那么他们就会同一时刻来访问查询缓存，都没查到，接着同一时间去访问数据库，同时的去执行数据库代码，对数据库访问压力过大

2.解决方案

2.1.互斥锁（分布式锁）

因为锁能实现互斥性。假设线程过来，只能一个人一个人的来访问数据库，从而避免对于数据库访问压力过大，但这也会影响查询的性能，因为此时会让查询的性能从并行变成了串行，我们可以采用tryLock方法 + double check来解决这样的问题。

假设现在线程1过来访问，他查询缓存没有命中，但是此时他获得到了锁的资源，那么线程1就会一个人去执行逻辑，假设现在线程2过来，线程2在执行过程中，并没有获得到锁，那么线程2就可以进行到休眠，直到线程1把锁释放后，线程2获得到锁，然后再来执行逻辑，此时就能够从缓存中拿到数据了。

2.2.设置逻辑过期

方案分析：我们之所以会出现这个缓存击穿问题，主要原因是在于我们对key设置了过期时间，假设我们不设置过期时间，其实就不会有缓存击穿的问题，但是不设置过期时间，这样数据不就一直占用我们内存了吗，我们可以采用逻辑过期方案。

我们把过期时间设置在 redis的value中，注意：这个过期时间并不会直接作用于redis，而是我们后续通过逻辑去处理。假设线程1去查询缓存，然后从value中判断出来当前的数据已经过期了，此时线程1去获得互斥锁，那么其他线程会进行阻塞，获得了锁的线程他会开启一个新线程去进行以前的重构数据的逻辑，直到新开的线程完成这个逻辑后，才释放锁，而线程1直接进行返回，假设现在线程3过来访问，由于线程线程2持有着锁，所以线程3无法获得锁，线程3也直接返回数据，只有等到新开的线程2把重建数据构建完后，其他线程才能走返回正确的数据。

这种方案巧妙在于，异步的构建缓存，缺点在于在构建完缓存之前，返回的都是脏数据。

进行对比

互斥锁方案：由于保证了互斥性，所以数据一致，且实现简单，因为仅仅只需要加一把锁而已，也没其他的事情需要操心，所以没有额外的内存消耗，缺点在于有锁就有死锁问题的发生，且只能串行执行性能肯定受到影响

逻辑过期方案： 线程读取过程中不需要等待，性能好，有一个额外的线程持有锁去进行重构数据，但是在重构数据完成前，其他的线程只能返回之前的数据，且实现起来麻烦

3.利用互斥锁解决缓存击穿问题

核心思路：相较于原来从缓存中查询不到数据后直接查询数据库而言，现在的方案是进行查询之后，如果从缓存没有查询到数据，则进行互斥锁的获取，获取互斥锁后，判断是否获得到了锁，如果没有获得到，则休眠，过一会再进行尝试，直到获取到锁为止，才能进行查询

如果获取到了锁的线程，再去进行查询，查询后将数据写入redis，再释放锁，返回数据，利用互斥锁就能保证只有一个线程去执行操作数据库的逻辑，防止缓存击穿

操作锁的代码：

核心思路就是利用redis的setnx方法来表示获取锁，该方法含义是redis中如果没有这个key，则插入成功，返回1，在stringRedisTemplate中返回true，如果有这个key则插入失败，则返回0，在stringRedisTemplate返回false，我们可以通过true，或者是false，来表示是否有线程成功插入key，成功插入的key的线程我们认为他就是获得到锁的线程。

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){//1.从redis查询商铺缓存String key = RedisConstants.CACHE_SHOP_KEY + id;String shopJson = stringRedisTemplate.opsForValue().get(key);//2.判断是否存在if(StrUtil.isNotBlank(shopJson)){//3.存在，返回商铺信息return JSONUtil.toBean(shopJson, Shop.class);}//判断命中的是否为空值if(shopJson != null){//返回错误信息return null;}//4.实现缓存重建//4.1.获取互斥锁String lockKey = RedisConstants.LOCK_SHOP_KEY + id;Shop shop;try {boolean isLock = tryLock(lockKey);//4.2.判断是否获取成功if(!isLock){//4.3.如果失败，则休眠，并重试Thread.sleep(50);return queryWithMutex(id);}//获取锁成功也要再次判断redis中缓存是否存在，做双重校验shopJson = stringRedisTemplate.opsForValue().get(key);//2.判断是否存在if(StrUtil.isNotBlank(shopJson)){//3.存在，返回商铺信息return JSONUtil.toBean(shopJson, Shop.class);}//4.4.如果成功获取锁，根据id查询数据库shop = getById(id);//模拟重建的耗时Thread.sleep(200);//5判断数据库中是否存在if(shop == null){//6.数据库中不存在,返回错误信息，并且缓存空数据stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);return null;}//7.数据库中存在，将商铺信息写入redis，返回商铺信息stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop));//8.设置过期时间stringRedisTemplate.expire(key,RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);} catch (InterruptedException e){throw new RuntimeException(e);} finally {//9.释放互斥锁unLock(lockKey);}return shop;}

4.测试

先把redis中的缓存清掉，然后重启服务，清空控制台

我们使用Jmeter开启1000线程在5秒内访问/shop/1这个接口，并发量大概达到200QPS。

可以看到，结果全成功访问：

并且控制台也只打印了一次查询Mysql的日志，说明只有一次请求（第一次）打到数据库上了：

redis中也缓存了cache:shop:1的数据：

说明我们基于互斥锁解决缓存击穿问题得以实现！

5.基于逻辑过期解决缓存击穿问题

一般情况热点key问题都是在活动期间，会提前把热点Key进行预热到redis中，如果没预热到redis中，说明不是热点key，就无需管它

需求：修改根据id查询商铺的业务，基于逻辑过期方式来解决缓存击穿问题

思路分析：当用户开始查询redis时，判断是否命中，如果没有命中（说明不是热点key）则直接返回空数据，不查询数据库，而一旦命中后，将value取出，判断value中的过期时间是否满足，如果没有过期，则直接返回redis中的数据，如果过期，则在开启独立线程后直接返回之前的数据，独立线程去重构数据，重构完成后释放互斥锁。

如果封装数据：因为现在redis中存储的数据的value需要带上过期时间，此时要么你去修改原来的实体类，要么你可以新建一个实体类，对Java对象和过期时间封装

我们采用第二种方式，这样对原来的代码没有侵入性

步骤一：新建一个实体类

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

步骤二：在ShopServiceImpl 新增此方法，利用单元测试进行缓存预热（意思就是我们程序员先把数据存入redis，避免用户第一次来访问的时候再存）：

 public void saveShop2Redis(Long id,Long expireSeconds){//1.查询店铺数据Shop shop = getById(id);try {Thread.sleep(200);} catch (InterruptedException e) {throw new RuntimeException(e);}//2.封装逻辑过期时间RedisData redisData = new RedisData();redisData.setData(shop);redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));//3.写入redisstringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(redisData));}

写一个测试类：

@SpringBootTest
class HmDianPingApplicationTests {@Resourceprivate ShopServiceImpl shopService;@Testvoid testSaveShop(){shopService.saveShop2Redis(1L,20L);}
}

先跑一遍测试类，然后就会在redis中存入数据：

步骤三：修改正式代码：ShopServiceImpl:

public Shop queryWithLogicalExpire(Long id){//1.从redis查询商铺缓存String key = RedisConstants.CACHE_SHOP_KEY + id;String shopJson = stringRedisTemplate.opsForValue().get(key);//2.判断是否存在if(StrUtil.isBlank(shopJson)){//3.不存在，返回商铺信息return null;}//4.命中，需要先把json反序列化为对象RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);JSONObject data = (JSONObject) redisData.getData();Shop shop = JSONUtil.toBean(data, Shop.class);LocalDateTime expireTime = redisData.getExpireTime();//5.判断是否过期if(expireTime.isAfter(LocalDateTime.now())){//5.1 未过期，直接返回店铺信息return shop;}//5.2 已过期，需要缓存重建//6.缓存重建//6.1 获取互斥锁String lockKey = RedisConstants.LOCK_SHOP_KEY + id;boolean isLock = tryLock(lockKey);//6.2.判断是否获取锁成功if(isLock) {//获取到锁之后，需再次判断redis中的缓存是否过期，做二次校验，如果存在则无需缓存重建//6.3 获取锁成功，开启独立线程，实现缓存重建shopJson = stringRedisTemplate.opsForValue().get(key);//2.判断是否存在if(StrUtil.isBlank(shopJson)){//3.不存在，返回商铺信息return null;}//4.命中，需要先把json反序列化为对象redisData = JSONUtil.toBean(shopJson, RedisData.class);data = (JSONObject) redisData.getData();shop = JSONUtil.toBean(data, Shop.class);expireTime = redisData.getExpireTime();//5.判断是否过期if(expireTime.isAfter(LocalDateTime.now())){//5.1 未过期，直接返回店铺信息return shop;}CACHE_REBUILD_EXECUTOR.submit(()->{try {this.saveShop2Redis(id,20L);} catch (Exception e) {throw new RuntimeException(e);} finally {//释放锁unLock(lockKey);}});}//6.4 失败，直接返回过期的商铺信息return shop;}