缓存三剑客：击穿、穿透、雪崩——从青铜到王者的防御指南-优快云博客

本文链接：https://blog.youkuaiyun.com/hellojava6666/article/details/146314556

导语： 深夜12点，某电商平台突然出现诡异现象：某爆款商品页面访问量暴增，但数据库CPU飙升到98%，Redis监控却显示缓存命中率归零。这究竟是道德的沦丧，还是技术的失守？让我们揭开缓存世界三大杀手的真面目。

一、缓存击穿：百万流量压垮一根稻草

1.1 致命现场还原

某日，价值9999元的茅台秒杀活动开启前，技术团队将商品信息缓存设置为5分钟过期。当缓存失效的瞬间，10万QPS如洪水般涌向数据库...

概念本质： 高并发场景下，某个热点Key突然失效，所有请求穿透到数据库，就像高压水枪冲击一根脆弱的吸管。

1.2 防御武器库（Java实战）

方案一：互斥锁（分布式锁）

public Product getProductWithLock(String key) {
    Product product = redisTemplate.opsForValue().get(key);
    if (product == null) {
        RLock lock = redissonClient.getLock("LOCK_" + key);
        try {
            if (lock.tryLock(3, 30, TimeUnit.SECONDS)) {
                product = dbQuery(key); // 伪代码：数据库查询
                redisTemplate.opsForValue().set(key, product, 30, TimeUnit.MINUTES);
            } else {
                Thread.sleep(50); // 优化点：阶梯式等待
                return getProductWithLock(key); // 递归重试
            }
        } finally {
            lock.unlock();
        }
    }
    return product;
}

方案二：逻辑过期时间（无锁方案）

// 实体类增强
@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

public Product getProductLogicExpire(String key) {
    RedisData redisData = redisTemplate.opsForValue().get(key);
    if (redisData == null) {
        return dbQueryAndRebuild(key); // 触发缓存重建
    }
    if (redisData.getExpireTime().isAfter(LocalDateTime.now())) {
        return (Product) redisData.getData();
    }
    // 异步更新线程池
    cacheRebuildExecutor.submit(() -> {
        RLock lock = redissonClient.getLock("REBUILD_" + key);
        if (lock.tryLock()) {
            try {
                dbQueryAndRebuild(key);
            } finally {
                lock.unlock();
            }
        }
    });
    return (Product) redisData.getData(); // 返回旧数据
}

技术深潜： 对比Redisson与Curator实现分布式锁的性能差异，在1000并发下，Redisson的吞吐量高出37%，但ZooKeeper在强一致性场景更可靠。

二、缓存穿透：黑客的穿甲弹攻击

2.1 攻击者视角

黑客使用脚本连续请求id=-1到id=-10000的商品信息，Redis和数据库层层失守...

核心矛盾： 缓存层与存储层都无法命中，导致每次请求都直达数据库，就像穿甲弹洞穿所有防御。

2.2 立体防御体系

方案一：布隆过滤器（概率武器）

// 初始化布隆过滤器
RBloomFilter<String> bloomFilter = redissonClient.getBloomFilter("productBloom");
bloomFilter.tryInit(1000000L, 0.03); 

public Product getProductWithBloom(String id) {
    if (!bloomFilter.contains(id)) {
        return null; // 拦截非法请求
    }
    // ...后续查询逻辑
}

// 数据库数据同步（定时任务）
@Scheduled(cron = "0 0 3 * * ?")
public void bloomFilterSync() {
    List<String> allIds = productDao.getAllIds();
    allIds.forEach(id -> bloomFilter.add(id));
}

方案二：空值缓存（陷阱防御）

public Product getProductNullCache(String id) {
    String cacheKey = "product:" + id;
    Product product = redisTemplate.opsForValue().get(cacheKey);
    if (product != null) {
        return product instanceof NullProduct ? null : product;
    }
    
    product = productDao.getById(id);
    if (product == null) {
        redisTemplate.opsForValue().set(cacheKey, new NullProduct(), 5, TimeUnit.MINUTES);
        return null;
    }
    redisTemplate.opsForValue().set(cacheKey, product, 30, TimeUnit.MINUTES);
    return product;
}

攻防演练： 实测显示，布隆过滤器在100万数据量下内存占用仅约4MB（误差率3%），而传统HashMap需要约80MB。

三、缓存雪崩：数字世界的链式崩塌

3.1 灾难场景重现

某金融系统在00:00进行缓存刷新，10万+Key同时失效，数据库连接池瞬间被打满...

破坏力分析： 大规模缓存集体失效，引发的链式反应可能导致整个系统瘫痪，堪比数字世界的雪崩效应。

3.2 雪崩防御工事

方案一：过期时间随机化

// Spring Cache扩展
public class RandomTtlCacheManager extends RedisCacheManager {
    
    private final int baseTtl;
    private final int randomRange;

    public RandomTtlCacheManager(... int baseTtl, int randomRange) {
        this.baseTtl = baseTtl;
        this.randomRange = randomRange;
    }

    @Override
    protected RedisCache createRedisCache(String name, RedisCacheConfiguration config) {
        int randomTtl = baseTtl + new Random().nextInt(randomRange);
        return super.createRedisCache(name, config.entryTtl(Duration.ofSeconds(randomTtl)));
    }
}

方案二：多级缓存架构

// Caffeine本地缓存 + Redis
@Bean
public CacheManager cacheManager() {
    CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
    caffeineCacheManager.setCaffeine(Caffeine.newBuilder()
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .maximumSize(1000));
    
    RedisCacheManager redisCacheManager = new RedisCacheManager(...);
    
    // 组合缓存管理器
    return new CompositeCacheManager(
        caffeineCacheManager, 
        redisCacheManager
    );
}

// 查询优先本地缓存
public Product getProductMultiLevel(String id) {
    Product product = localCache.get(id, Product.class);
    if (product == null) {
        product = redisTemplate.opsForValue().get("product:" + id);
        if (product != null) {
            localCache.put(id, product);
        }
    }
    return product;
}

架构演进： 某电商平台接入多级缓存后，Redis集群QPS下降60%，数据库负载降低至原来的1/4。

四、防御矩阵：组合拳实战

4.1 综合防御方案

public Product getProductFinal(String id) {
    // 第一层：参数校验
    if (!ValidUtil.isValidId(id)) {
        throw new IllegalArgumentException();
    }
    
    // 第二层：布隆过滤器
    if (!bloomFilter.mightContain(id)) {
        return null;
    }
    
    // 第三层：多级缓存
    Product product = compositeCache.get(id);
    if (product != null) {
        return product instanceof NullProduct ? null : product;
    }
    
    // 第四层：分布式锁重建
    return lockAndRebuild(id);
}

// 第五层：熔断降级
@HystrixCommand(fallbackMethod = "getProductFallback")
public Product getProductHystrix(String id) {
    return getProductFinal(id);
}

性能指标： 在模拟100万次请求的测试中，完整防御体系将数据库查询次数从78万次降至1200次，降幅达99.8%。