Redis缓存击穿的用法及说明

// 1. 注入RedisTemplate（SpringBoot环境）
@Autowired
private RedisTemplate<String, Object> redisTemplate;

// 2. 互斥锁核心方法（获取锁+查询数据库+更新缓存）
public Object getValueByMutexLock(String key) {
    // 第一步：查询缓存
    Object value = redisTemplate.opsForValue().get(key);
    if (value != null) {
        return value; // 缓存存在，直接返回
    }
    
    // 第二步：缓存不存在，尝试获取分布式锁
    String lockKey = "lock:" + key; // 锁key，与业务key绑定，避免锁冲突
    String lockValue = UUID.randomUUID().toString(); // 唯一值，用于释放锁
    boolean isLock = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, lockValue, 3, TimeUnit.SECONDS); // 锁过期时间3秒（根据数据库查询耗时调整）
    
    if (isLock) {
        try {
            // 第三步：获取锁成功，查询数据库
            value = queryDatabase(key); // 自定义方法，查询数据库数据
            // 第四步：将数据库数据写入缓存，设置过期时间（避免再次击穿）
            redisTemplate.opsForValue().set(key, value, 30, TimeUnit.MINUTES);
            return value;
        } finally {
            // 第五步：释放锁（必须在finally中，避免死锁）
            // 对比value确保是自己的锁，避免误释放他人的锁
            if (lockValue.equals(redisTemplate.opsForValue().get(lockKey))) {
                redisTemplate.delete(lockKey);
            }
        }
    } else {
        // 第六步：获取锁失败，重试（间隔100ms，避免频繁重试）
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return getValueByMutexLock(key); // 递归重试，也可使用循环
    }
}

// 模拟数据库查询方法
private Object queryDatabase(String key) {
    // 实际业务中替换为真实数据库查询逻辑（如MyBatis查询）
    return "数据库查询到的" + key + "对应数据";
}

// 1. 定义缓存数据封装类（封装业务数据+逻辑过期时间）
@Data
public class CacheData<T> {
    // 业务数据
    private T data;
    // 逻辑过期时间（时间戳，单位：毫秒）
    private Long expireTime;
}

// 2. 注入依赖（SpringBoot环境）
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// 异步线程池（用于逻辑过期后异步更新缓存）
@Autowired
private ThreadPoolTaskExecutor asyncTaskExecutor;

// 3. 逻辑过期核心方法
public Object getValueByLogicalExpire(String key) {
    // 第一步：查询Redis缓存（获取封装后的CacheData对象）
    CacheData<Object> cacheData = (CacheData<Object>) redisTemplate.opsForValue().get(key);
    if (cacheData == null) {
        // 缓存不存在（首次请求/缓存被手动删除），此处可返回兜底数据或查询数据库
        return queryDatabase(key);
    }
    
    // 第二步：判断逻辑过期时间是否已到
    Long currentTime = System.currentTimeMillis();
    if (currentTime < cacheData.getExpireTime()) {
        // 逻辑未过期，直接返回业务数据
        return cacheData.getData();
    }
    
    // 第三步：逻辑已过期，返回旧数据，同时异步更新缓存
    asyncTaskExecutor.execute(() -> {
        try {
            // 异步查询数据库最新数据
            Object newData = queryDatabase(key);
            // 重新封装CacheData，设置新的逻辑过期时间（如30分钟后）
            CacheData&lt;Object&gt; newCacheData = new CacheData<>();
            newCacheData.setData(newData);
            newCacheData.setExpireTime(System.currentTimeMillis() + 30 * 60 * 1000);
            // 更新Redis缓存（无物理过期时间）
            redisTemplate.opsForValue().set(key, newCacheData);
        } catch (Exception e) {
            // 异常处理（如日志记录），避免异步任务失败导致缓存无法更新
            log.error("逻辑过期缓存更新失败，key:{}", key, e);
        }
    });
    
    // 直接返回旧数据，不阻塞当前请求
    return cacheData.getData();
}

// 模拟数据库查询方法（与互斥锁方案一致）
private Object queryDatabase(String key) {
    return "数据库查询到的" + key + "对应数据";
}

// 4. 初始化缓存（缓存预热，存入带逻辑过期时间的数据）
public void initCache(String key) {
    Object data = queryDatabase(key);
    CacheData&lt;Object&gt; cacheData = new CacheData<>();
    cacheData.setData(data);
    // 设置逻辑过期时间（30分钟）
    cacheData.setExpireTime(System.currentTimeMillis() + 30 * 60 * 1000);
    // 存入Redis，不设置物理过期时间
    redisTemplate.opsForValue().set(key, cacheData);
}