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.写入redis
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(redisData));

    }

写一个测试类：

@SpringBootTest
class HmDianPingApplicationTests {

    @Resource
    private ShopServiceImpl shopService;

    @Test
    void 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;
    }

此时我们重启服务，但是别把redis中我们预热的缓存删掉！！

然后我们把数据库中的数据改一下（改成 103餐厅）：