缓存击穿问题以及解决思路
缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。
逻辑分析：假设线程1在查询缓存之后，本来应该去查询数据库，然后把这个数据重新加载到缓存的，此时只要线程1走完这个逻辑，其他线程就都能从缓存中加载这些数据了，但是假设在线程1没有走完的时候，后续的线程2，线程3，线程4同时过来访问当前这个方法， 那么这些线程都不能从缓存中查询到数据，那么他们就会同一时刻来访问查询缓存，都没查到，接着同一时间去访问数据库，同时的去执行数据库代码，对数据库访问压力过大
[!note] 重建缓存触发场景 缓存过期 ：缓存数据设置了过期时间，当过期时间到达后，缓存失效，需要重建。比如在 Redis 中，设置了某个 key 的过期时间为 1 小时，1 小时后该 key 对应的缓存数据就会失效，需要重新从数据库获取数据并写入缓存。
方案一 互斥锁
使用互斥锁，确保同一时间只有一个线程重建缓存
因为锁能实现互斥性。假设线程过来，只能一个人一个人的来访问数据库，从而避免对于数据库访问压力过大，但这也会影响查询的性能，因为此时会让查询的性能从并行变成了串行，我们可以采用tryLock方法 + double check来解决这样的问题。
假设现在线程1过来访问，他查询缓存没有命中，但是此时他获得到了锁的资源，那么线程1就会一个人去执行逻辑，假设现在线程2过来，线程2在执行过程中，并没有获得到锁，那么线程2就可以进行到休眠，直到线程1把锁释放后，线程2获得到锁，然后再来执行逻辑，此时就能够从缓存中拿到数据了。
方案二 逻辑过期
采用逻辑过期的方式，在缓存中存储数据时附加一个过期时间，当查询到缓存过期时，先返回旧数据，同时异步重建缓存
方案分析：我们之所以会出现这个缓存击穿问题，主要原因是在于我们对key设置了过期时间，假设我们不设置过期时间，其实就不会有缓存击穿的问题，但是不设置过期时间，这样数据不就一直占用我们内存了吗，我们可以采用逻辑过期方案。
我们把过期时间设置在 redis的value中，注意：这个过期时间并不会直接作用于redis，而是我们后续通过逻辑去处理。假设线程1去查询缓存，然后从value中判断出来当前的数据已经过期了，此时线程1去获得互斥锁，那么其他线程会进行阻塞，获得了锁的线程他会开启一个 线程去进行 以前的重构数据的逻辑，直到新开的线程完成这个逻辑后，才释放锁， 而线程1直接进行返回，假设现在线程3过来访问，由于线程线程2持有着锁，所以线程3无法获得锁，线程3也直接返回数据，只有等到新开的线程2把重建数据构建完后，其他线程才能走返回正确的数据。
这种方案巧妙在于，异步的构建缓存，缺点在于在构建完缓存之前，返回的都是脏数据。
互斥锁方案：由于保证了互斥性，所以数据一致，且实现简单，因为仅仅只需要加一把锁而已，也没其他的事情需要操心，所以没有额外的内存消耗，缺点在于有锁就有死锁问题的发生，且只能串行执行性能肯定受到影响
逻辑过期方案： 线程读取过程中不需要等待，性能好，有一个额外的线程持有锁去进行重构数据，但是在重构数据完成前，其他的线程只能返回之前的数据，且实现起来麻烦
利用互斥锁解决缓存击穿问题
核心思路：相较于原来从缓存中查询不到数据后直接查询数据库而言，现在的方案是 进行查询之后，如果从缓存没有查询到数据，则进行互斥锁的获取，获取互斥锁后，判断是否获得到了锁，如果没有获得到，则休眠，过一会再进行尝试，直到获取到锁为止，才能进行查询
如果获取到了锁的线程，再去进行查询，查询后将数据写入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){ //从Redis查询商铺缓存 String shopKey = CACHE_SHOP_KEY + id; String shopJson = stringRedisTemplate.opsForValue().get(shopKey);
//判断是否存在 if (StrUtil.isNotBlank(shopJson)) { //存在，直接返回 Shop shop = JSONUtil.toBean(shopJson, Shop.class); return shop; } //判断命中的是否是空值 if (shopJson != null) { return null; }
//缓存未命中，获取锁，成功则查询数据库，失败则休眠，尝试从缓存获取 String lockKey = LOCK_SHOP_KEY; Shop shop = null; try { boolean isLock = tryLock(lockKey); if (!isLock) { //失败，休眠并重试 Thread.sleep(50); return queryWithMutex(id); } //成功，根据id查询数据库 //模拟耗时 Thread.sleep(200); shop = getById(id); //判断是否为空 if (shop == null) { //将空值写入redis stringRedisTemplate.opsForValue().set(shopKey, "", CACHE_NULL_TTL, TimeUnit.MINUTES); return null;
} //存在，写入redis stringRedisTemplate.opsForValue().set(shopKey, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES); } catch (InterruptedException e) { throw new RuntimeException(e); } finally { //释放锁 unlock(lockKey); } //返回 return shop;
}利用逻辑过期解决缓存击穿问题
需求：修改根据id查询商铺的业务，基于逻辑过期方式来解决缓存击穿问题
思路分析：当用户开始查询redis时，判断是否命中，如果没有命中则直接返回空数据，不查询数据库，而一旦命中后，将value取出，判断value中的过期时间是否满足，如果没有过期，则直接返回redis中的数据，如果过期，则在开启独立线程后直接返回之前的数据，独立线程去重构数据，重构完成后释放互斥锁。
现在redis中存储的数据的value需要带上过期时间，此时要么你去修改原来的实体类，要么你新建一个实体类 步骤一、
我们采用第二个方案，这个方案，对原来代码没有侵入性。
@Datapublic class RedisData { private LocalDateTime expireTime; private Object data;}步骤二、
在ShopServiceImpl 新增此方法
/** * 尝试获取锁 * @param key * @return */private boolean tryLock(String key) { Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS); return BooleanUtil.isTrue(flag);}
/** * 释放锁 * @param key */private void unlock(String key) { stringRedisTemplate.delete(key);}public void saveShop2Redis(Long id,Long expireSeconds) { //查询店铺数据 Shop shop = getById(id); //创建逻辑过期时间 Thread.sleep(1000); RedisData redisData = new RedisData(); redisData.setData(shop); redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds)); //写入Redis stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id ,JSONUtil.toJsonStr(redisData));}private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
public Shop queryWithLogicalExpire(Long id) {
//从Redis查询商铺缓存 String shopKey = CACHE_SHOP_KEY + id; String shopJson = stringRedisTemplate.opsForValue().get(shopKey);
//判断是否存在 if (StrUtil.isBlank(shopJson)) { //缓存未命中，直接返回null return null; } //命中，判断缓存是否过期 RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class); LocalDateTime expireTime = redisData.getExpireTime(); JSONObject data = (JSONObject) redisData.getData(); Shop shop = JSONUtil.toBean(data, Shop.class);
if (expireTime.isAfter(LocalDateTime.now())){ //未过期，直接返回店铺信息 return shop; } //过期，缓存重建 //获取锁 String lockKey = LOCK_SHOP_KEY + id; boolean isLock = tryLock(lockKey); if (isLock) { // 双重检查：再次验证缓存是否已经更新 String shopJson2 = stringRedisTemplate.opsForValue().get(shopKey); RedisData redisData2 = JSONUtil.toBean(shopJson2, RedisData.class); LocalDateTime expireTime2 = redisData2.getExpireTime();
if (expireTime2.isAfter(LocalDateTime.now())) { // 如果已更新，则不再重建缓存 unlock(lockKey); return shop; } //获取成功 ，开启独立线程，实现缓存重建 CACHE_REBUILD_EXECUTOR.submit(() -> { //重建缓存 try { saveShop2Redis(id,20L); } catch (Exception e) { throw new RuntimeException(e); } finally { //释放锁 unlock(lockKey); } }); } //获取失败，返回旧数据 return shop;}
/** * 重建缓存数据 * @param id * @param expireSeconds * @throws InterruptedException */public void saveShop2Redis(Long id,Long expireSeconds) throws InterruptedException { //查询店铺数据 Shop shop = getById(id); //创建逻辑过期时间 Thread.sleep(1000); RedisData redisData = new RedisData(); redisData.setData(shop); redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds)); //写入Redis stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id ,JSONUtil.toJsonStr(redisData));}部分信息可能已经过时