1. 缓存击穿产生

也叫做 热点 Key 问题，高并发访问并且缓存重建业务较复杂的 key 突然失效了，无数的请求想要重建缓存，大量的访问会在瞬间给数据库带来巨大冲击。

2. 解决方案

2.1 方案一：互斥锁

查询缓存不存在时，为查询数据库重构缓存这一操作加一互斥锁，使得多线程并发下，只有一个线程去查询数据库，其他线程等待，减小对数据库的压力。

优点：

• 无额外内存消耗
• 能保证一致性
• 实现起来比较简单

缺点：

• 进程需要等待，性能受到影响：所有请求都必须等待第一个线程完成缓存重构。
• 可能会有死锁的风险：可能我获取了一个锁了，另一个锁在另一个业务那里，但是另一个业务也等待着我释放锁，我们两个互相等待对方释放，导致死锁。

互斥锁的代码实现：

使用 setnx 命令获取锁，使用 del 释放锁 ，setnx 命令对应 StringRedisTemplate 中的 opsForValue().setIfAbsent ，设置成功返回 true，设置失败返回 fasle 。

    public static final String CACHE_SHOPSTYPE_LIST = "cache:shopsType:";
    @Resource
    private StringRedisTemplate stringRedisTemplate; // 注入

    // 获取锁的方法
    private boolean tryLock(String key){
        boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag); // 防止出现 null
    }

    // 释放锁的方法
    private void unlock(String key){
        stringRedisTemplate.delete(key);
    }
    
   // 解决缓存击穿
    public  Shop queryWithMutex(Long id)  {
    
        String key = CACHE_SHOP_KEY  + id;
        // 1. 从 Redis 中查询商户缓存
        String shonJson = stringRedisTemplate.opsForValue().get(key);        // 2. 判断是否存在

        // 2. 命中真实值，返回数据
        if(!StringUtil.isNullOrEmpty(shonJson)){
            Shop shop = JSONUtil.toBean(shonJson, Shop.class);
            return shop;
        }
        
        // 3. 命中空字符串，返回null (缓存穿透的添加空值解决方案)
        if(shonJson != null){
            return null;
        }

        // 4. 实现缓存重建
        try {
        
            // 4.1. 获取互斥锁
            boolean isLock = tryLock("lock:shop:" + id);
            
            // 4.2. 获取失败，等待一段时间，再去请求缓存 —— 使用递归实现
            if(!isLock){
                Thread.sleep(50);
                return queryWithMutex(id);
            }
            
            // 4.3. 获取成功，重建缓存
            Thread.sleep(200); // 模拟重建延迟
            
            // 4.3.1. 查询数据库
            shop = getById(id);
            
            // 4.3.1.1 数据库不存在 —— 将空值写入缓存（缓存穿透解决方案），返回 null
            if(shop == null){
                stringRedisTemplate.opsForValue().set(key, "", 2L, TimeUnit.MINUTES);
                return null;
            }
            
            // 4.3.1.2 数据库存在 —— 写入 Redis ，然后返回，实现缓存重建
            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), 30L, TimeUnit.MINUTES);
            
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
        
            // 11. 缓存重构结束，释放锁
            unlock("lock:shop:" + id);
            
        }
        return shop;
    }

2.2 方案二：逻辑过期

不设置 TTL ，为 Value 加上 expire 逻辑过期时间，通过业务逻辑判断缓存是否过期。

这样线程去查询缓存，其会判断逻辑时间是否过期，过期了会另开一个新线程，去更新数据。本线程不等待，直接返回过期的数据。若同时，另一个线程也来查询，发现得不到互斥锁，就会直接返回过期的数据，而不会等待。

优点：

• 线程无需等待，性能好

缺点：

• 不保证一致性
• 有额外内存消耗
• 实现复杂，需要进行逻辑判断

逻辑过期的代码实现

1. 把对象封装为 RedisData ，在 RedisData 中添加 LocalDateTime 属性

package com.hmdp.utils;
import lombok.Data;
import java.time.LocalDateTime;

@Data
public class RedisData { // 把对象封装为 RedisData ，存入 Redis 中
    private LocalDateTime expireTime;
    private Object data;
}

2. 逻辑过期关键代码实现

解释： 使用线程池开启新线程执行缓存重构，其他的线程直接返回过期数据。

    // 创建一线程池
    private  static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    // 获取锁的方法
    private boolean tryLock(String key){
        boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag); // 防止出现 null
    }

    // 释放锁的方法
    private void unlock(String key){
        stringRedisTemplate.delete(key);
    }
    
    // 缓存重构方法，为对象加入 expireSeconds 逻辑过期时间 
    // 传递的指为要缓存的对象 id ，和缓存的时间
    public void saveShop2Redis(Long id, Long expireSeconds) throws InterruptedException {
        Shop shop;
        shop = getById(id);
        Thread.sleep(200);
        if (shop == null){
            log.info("为 null");
        }
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id, JSONUtil.toJsonStr(redisData));
    }
    
    // 使用逻辑过期的方式解决缓存击穿
    public  Shop queryWithLogicalExpire(Long id)  {
        String key = CACHE_SHOP_KEY  + id;
        
        // 1. 从 Redis 中查询商户缓存
        String shonJson = stringRedisTemplate.opsForValue().get(key);        // 2. 判断是否存在

        // 2. 未命中
        if(StringUtil.isNullOrEmpty(shonJson)){
            return null;
        }
        
        // 3. 命中
        // 3.1 得到缓存对象 —— JSON 反序列化为 RedisData 对象
        RedisData redisData = JSONUtil.toBean(shonJson, RedisData.class);
        JSONObject data = (JSONObject)redisData.getData();
        Shop shop = JSONUtil.toBean(data, Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime(); // 得到过期时间
        
        // 3.2 判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())){
            // 3.2.1 未过期，直接返回
            return shop;
        }
        
        // 3.2.1 过期，需要进行缓存重建
        // 3.2.1.1 获取互斥锁
        String lockKey = "lock:shop:" + id; // 锁的 key
        boolean isLock = tryLock(lockKey);
        
        // 3.2.1.2 判断是否成功获取到互斥锁
        // 3.2.1.2.1 获取互斥锁失败，直接返回过期数据
        if(!isLock){
            return shop;
        }
        
        // 3.2.1.2.2 获取互斥锁成功，在开启一个线程进行缓存重建，然后返回数据
        CACHE_REBUILD_EXECUTOR.submit(()->{
            try {
                // 重建
                saveShop2Redis(id, 20L); // 设置 30 分钟
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                // 释放锁
                unlock(lockKey);
            }
        });
        
        return shop;
    }