【Redis】Redis缓存击穿

[一. 什么是缓存击穿](#一. 什么是缓存击穿)

[二. 缓存击穿的核心原因](#二. 缓存击穿的核心原因)

[1. 存在高频访问的热点key](#1. 存在高频访问的热点key)

[2. 缓存key过期失效](#2. 缓存key过期失效)

[3. 缓存与数据库之间无兜底机制](#3. 缓存与数据库之间无兜底机制)

[三. 缓存击穿的危害](#三. 缓存击穿的危害)

[四. 缓存击穿的解决方案](#四. 缓存击穿的解决方案)

方案一：互斥锁

方案二：逻辑过期

一. 什么是缓存击穿

缓存击穿，指的是某一个热点key（被高频访问的key），在缓存中过期失效的瞬间，大量的请求直接穿透缓存，涌向数据库，导致数据库瞬时压力骤增，甚至被压垮的现象。

Tip:当请求打过来时，未在缓存中命中，去数据库查询数据就可能涉及到了很多表和数据库的查询汇总。这种情况就会出现查询数据时间很长，在这期间大量请求涌入数据库，它可能瞬间扛不住，就会出现响应超时、报错，甚至宕机

举个例子：比如电商平台的"爆款商品详情页"，这个商品的key在Redis中缓存了1小时，平时所有请求都走缓存，数据库几乎无压力。但当这个key过期的那一刻，刚好有1000个用户同时访问这个商品，此时缓存中没有数据，所有1000个请求都会直接打向数据库，数据库瞬间扛不住，就会出现响应超时、报错，甚至宕机。

这里要注意区分两个易混淆概念：

缓存穿透：是请求的key本身就不存在于缓存和数据库中，请求一直穿透到数据库。

缓存击穿：是请求的key存在于数据库中，但缓存刚好过期，瞬时请求穿透到数据库。

二. 缓存击穿的核心原因

1. 存在高频访问的热点key

如果key不是热点，即使缓存过期，也只有少量请求穿透到数据库，不会造成太大影响。只有当key被高频访问，才会在缓存失效瞬间对数据库造成巨大压力。

2. 缓存key过期失效

Redis的key都有过期时间，目的是为了释放内存，避免无效数据占用空间。但如果热点key的过期时间设置不合理，或者刚好在请求高峰时过期，就会触发击穿。

比如：把爆款商品的缓存时间设置为1小时，而刚好在晚上8点（用户访问高峰）过期，就极易引发击穿。

3. 缓存与数据库之间无兜底机制

如果缓存失效后，没有任何限流、降级、重试的机制，所有请求会毫无阻拦地冲向数据库，而数据库的并发处理能力远低于Redis，很容易被压垮。

三. 缓存击穿的危害

数据库压力骤增：瞬时大量请求穿透到数据库，导致数据库CPU、内存、IO占用率飙升，响应时间大幅延长。

系统响应超时：数据库处理不过来请求，会导致接口响应超时，前端出现加载失败、白屏等问题。

数据库宕机：如果请求量过大，超过数据库的承载极限，会导致数据库宕机，进而引发整个系统服务不可用。

连锁反应：数据库宕机后，即使缓存恢复，后续请求依然无法正常处理，可能导致服务雪崩，依赖该数据库的其他服务也跟着报错。

四. 缓存击穿的解决方案

方案一：互斥锁

当大量请求过来后走缓存

命中：直接返回缓存数据

未命中：让一个请求获取到锁去查询数据库重建缓存数据，其余未命中且未获取到锁的请求则休眠一段时间后，再次查询缓存。

特点：保证了很强的一致性，但是性能很差（有一段时间内其余未获取锁请求都在空闲等待）

java 复制代码

// 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 + "对应数据";
}

方案二：逻辑过期

我们不再设置key的物理过期时间，而是在缓存数据中嵌入一个逻辑过期时间字段。

当大量请求过来后走缓存判断查询字段是否已经过期

未过期：直接返回缓存数据

已过期：获取互斥锁，此时开启一个新的线程去查询数据库重建缓存，并且将其逻辑时间设置为当前时间+xxx分钟，释放锁的任务交给该新线程，开启新的线程后，直接返回过期的数据。在重建缓存过程中，其他线程进来查询缓存判断逻辑时间已经过期，且获取锁失败，直接给它返回刚刚缓存中查询出来的过期数据即可。

特点：不能保证数据绝对一致，但是高可用、性能优秀

java 复制代码

// 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);
}