缓存穿透、缓存击穿和缓存雪崩的概念及解决方案

1. 缓存穿透 (Cache Penetration)

1.1 概念

缓存穿透是指查询一个不存在的数据，由于缓存中没有，请求会直接穿透到数据库，如果大量此类请求发生，会对数据库造成巨大压力。

具体来说，当用户查询一个根本不存在的数据时：

1. 首先查询缓存，缓存中没有
2. 然后查询数据库，数据库中也没有
3. 不会将结果写入缓存（因为结果为空）
4. 如果有大量这样的请求，每次都会直接访问数据库

1.2 解决方案

1.2.1 缓存空对象

• 原理：即使数据库中查询不到数据，也将空结果（null）缓存起来，并设置较短的过期时间
• 优点：实现简单，能有效减少数据库查询
• 缺点：缓存中会存储大量空值，浪费缓存空间；如果数据确实被新增，需要主动清除缓存

// 伪代码示例
Object queryFromCache(key) {
    Object value = cache.get(key);
    if (value != null) {
        // 如果是空对象标记，直接返回null
        if (value instanceof NULL_OBJECT) {
            return null;
        }
        return value;
    }
    
    // 查询数据库
    value = db.query(key);
    
    // 即使查询结果为null，也缓存空对象
    if (value == null) {
        cache.set(key, NULL_OBJECT, SHORT_EXPIRE_TIME);
    } else {
        cache.set(key, value, NORMAL_EXPIRE_TIME);
    }
    
    return value;
}

1.2.2 布隆过滤器 (Bloom Filter)

• 原理：在访问缓存前，使用布隆过滤器快速判断数据是否存在
• 优点：内存占用小，查询效率高
• 缺点：有一定的误判率；不支持删除操作；需要预先加载数据

// 伪代码示例
Object queryWithBloomFilter(key) {
    // 先通过布隆过滤器判断key是否存在
    if (!bloomFilter.mightContain(key)) {
        return null;  // 直接返回，不查询数据库
    }
    
    // 查询缓存
    Object value = cache.get(key);
    if (value != null) {
        return value;
    }
    
    // 查询数据库
    value = db.query(key);
    if (value != null) {
        cache.set(key, value, NORMAL_EXPIRE_TIME);
    }
    
    return value;
}

1.2.3 接口层校验

• 原理：在接口层对请求参数进行合法性校验，拦截不合法的请求
• 优点：简单直接，能过滤掉明显无效的请求
• 缺点：只能过滤明显无效的请求，对于格式正确但实际不存在的请求无效

2. 缓存击穿 (Cache Breakdown)

2.1 概念

缓存击穿是指一个热点key在失效的瞬间，大量并发请求直接访问数据库，导致数据库压力骤增。

具体来说：

1. 某个key是热点数据，访问非常频繁
2. 该key在缓存中过期了
3. 大量并发请求同时发现缓存中没有该key
4. 所有请求同时访问数据库，造成数据库压力过大

2.2 解决方案

2.2.1 互斥锁 (Mutex Lock)

• 原理：当缓存失效时，只允许一个线程查询数据库并写回缓存，其他线程等待
• 优点：能有效防止大量请求同时访问数据库
• 缺点：增加了系统的响应时间；实现相对复杂

// 伪代码示例
Object queryWithMutexLock(key) {
    Object value = cache.get(key);
    if (value != null) {
        return value;
    }
    
    // 获取互斥锁
    String lockKey = "lock:" + key;
    try {
        // 尝试获取锁，设置很短的过期时间防止死锁
        boolean locked = redis.setnx(lockKey, "1", LOCK_EXPIRE_TIME);
        if (locked) {
            // 获取锁成功，查询数据库
            value = db.query(key);
            cache.set(key, value, NORMAL_EXPIRE_TIME);
            return value;
        } else {
            // 获取锁失败，短暂休眠后重试
            Thread.sleep(50);
            return queryWithMutexLock(key);  // 递归重试
        }
    } finally {
        // 释放锁
        redis.del(lockKey);
    }
}

2.2.2 热点数据永不过期

• 原理：对于热点数据，设置较长的过期时间或永不过期，通过后台任务定期更新
• 优点：实现简单，能有效避免缓存击穿
• 缺点：数据一致性可能受影响；需要额外的更新机制

// 伪代码示例
Object queryWithNeverExpire(key) {
    Object value = cache.get(key);
    if (value != null) {
        return value;
    }
    
    // 查询数据库
    value = db.query(key);
    
    // 设置很长的过期时间或永不过期
    cache.set(key, value, LONG_EXPIRE_TIME);
    
    // 启动后台任务定期更新
    scheduleUpdateTask(key);
    
    return value;
}

2.2.3 提前预热

• 原理：在热点数据过期前，主动刷新缓存
• 优点：能有效避免缓存失效时的并发问题
• 缺点：需要预测热点数据；实现相对复杂

// 伪代码示例
void preloadHotKeys() {
    // 获取所有热点key
    List<String> hotKeys = getHotKeys();
    
    for (String key : hotKeys) {
        // 检查key的剩余过期时间
        long ttl = cache.ttl(key);
        
        // 如果即将过期，提前刷新
        if (ttl < PRELOAD_THRESHOLD) {
            Object value = db.query(key);
            cache.set(key, value, NORMAL_EXPIRE_TIME);
        }
    }
}

3. 缓存雪崩 (Cache Avalanche)

3.1 概念

缓存雪崩是指大量key在同一时间失效，导致所有请求都直接访问数据库，造成数据库压力过大甚至宕机。

具体来说：

1. 大量key设置了相同的过期时间
2. 这些key在同一时间点失效
3. 大量请求同时发现缓存中没有数据
4. 所有请求同时访问数据库，导致数据库压力过大

3.2 解决方案

3.2.1 随机过期时间

• 原理：在基础过期时间上增加随机值，使key的失效时间分散
• 优点：实现简单，能有效避免大量key同时失效
• 缺点：不能完全避免雪崩，只是降低概率

// 伪代码示例
void setWithRandomExpire(key, value) {
    // 基础过期时间，例如1小时
    long baseExpire = 3600;
    
    // 随机增加0-30分钟
    long randomExpire = (long)(Math.random() * 1800);
    
    // 最终过期时间
    long totalExpire = baseExpire + randomExpire;
    
    cache.set(key, value, totalExpire);
}

3.2.2 缓存集群部署

• 原理：使用缓存集群，不同节点存储不同的数据，避免单点故障
• 优点：提高系统的可用性和稳定性
• 缺点：实现复杂，需要额外的资源

// 伪代码示例
Object queryFromCluster(key) {
    // 使用一致性哈希选择缓存节点
    CacheNode node = consistentHash.getNode(key);
    
    Object value = node.get(key);
    if (value != null) {
        return value;
    }
    
    // 查询数据库
    value = db.query(key);
    
    // 写入缓存，使用随机过期时间
    setWithRandomExpire(key, value);
    
    return value;
}

3.2.3 服务降级与熔断

• 原理：当检测到缓存异常或数据库压力过大时，启动服务降级或熔断机制
• 优点：保护系统不被击垮，保证核心功能可用
• 缺点：可能会牺牲部分用户体验；需要完善的监控和降级策略

// 伪代码示例
Object queryWithCircuitBreaker(key) {
    // 检查熔断器状态
    if (circuitBreaker.isOpen()) {
        // 熔断器开启，返回降级数据或默认值
        return getFallbackData(key);
    }
    
    try {
        Object value = cache.get(key);
        if (value != null) {
            // 重置熔断器
            circuitBreaker.reset();
            return value;
        }
        
        // 查询数据库
        value = db.query(key);
        cache.set(key, value, NORMAL_EXPIRE_TIME);
        
        // 重置熔断器
        circuitBreaker.reset();
        return value;
    } catch (Exception e) {
        // 记录失败
        circuitBreaker.recordFailure();
        
        // 如果达到阈值，开启熔断器
        if (circuitBreaker.isThresholdReached()) {
            circuitBreaker.open();
        }
        
        throw e;
    }
}

3.2.4 多级缓存架构

• 原理：使用多级缓存（如本地缓存+分布式缓存），减少对单一缓存的依赖
• 优点：提高系统稳定性，降低对数据库的压力
• 缺点：实现复杂，需要处理缓存一致性问题

// 伪代码示例
Object queryFromMultiLevelCache(key) {
    // 先查本地缓存
    Object value = localCache.get(key);
    if (value != null) {
        return value;
    }
    
    // 再查分布式缓存
    value = distributedCache.get(key);
    if (value != null) {
        // 回填本地缓存
        localCache.set(key, value, SHORT_EXPIRE_TIME);
        return value;
    }
    
    // 查询数据库
    value = db.query(key);
    
    // 写入分布式缓存，使用随机过期时间
    setWithRandomExpire(key, value);
    
    // 写入本地缓存
    localCache.set(key, value, SHORT_EXPIRE_TIME);
    
    return value;
}

4. 三种缓存问题的对比