Java缓存穿透与击穿：实战解决方案与深度解析

什么是缓存穿透与击穿？

在Java应用开发中，缓存是提升系统性能的利器，但使用不当也会带来各种问题。缓存穿透和缓存击穿是两种常见的缓存异常场景，它们都会导致数据库压力骤增，甚至引发系统崩溃。

缓存穿透指的是查询一个根本不存在的数据，由于缓存中没有，每次请求都会落到数据库上。想象一下，如果有人恶意构造大量不存在的ID来查询你的系统，数据库很快就会不堪重负。

缓存击穿则是指一个热点key突然失效，此时大量并发请求同时到达，直接穿透缓存打到数据库上。这种情况往往发生在缓存过期瞬间，对系统造成的冲击尤为严重。

缓存穿透的解决方案

布隆过滤器拦截

布隆过滤器是一种空间效率极高的概率型数据结构，可以用来判断一个元素是否在集合中。它的优点是空间效率和查询时间都远超过一般算法，缺点是有一定的误判率。

// 初始化布隆过滤器
BloomFilter<String> bloomFilter = BloomFilter.create(
    Funnels.stringFunnel(Charset.forName("UTF-8")), 
    1000000, 
    0.01);

// 预热数据
for(String key : allValidKeys) {
    bloomFilter.put(key);
}

// 查询前先检查
if(!bloomFilter.mightContain(key)) {
    return null; // 直接返回，不查询数据库
}

空值缓存策略

对于查询结果为null的情况，也可以将其缓存起来，设置一个较短的过期时间（如5分钟），防止频繁查询数据库。

public Object getData(String key) {
    Object value = cache.get(key);
    if(value != null) {
        if(value instanceof NullValue) {
            return null; // 空值标识
        }
        return value;
    }

    value = db.get(key);
    if(value == null) {
        cache.put(key, new NullValue(), 5, TimeUnit.MINUTES);
    } else {
        cache.put(key, value, 30, TimeUnit.MINUTES);
    }
    return value;
}

缓存击穿的应对之道

互斥锁机制

当缓存失效时，不是所有线程都去查询数据库，而是使用互斥锁，保证只有一个线程去查询数据库，其他线程等待查询结果。

public Object getDataWithLock(String key) {
    Object value = cache.get(key);
    if(value != null) {
        return value;
    }

    // 获取分布式锁
    String lockKey = "lock:" + key;
    try {
        if(lock.tryLock(lockKey, 10, TimeUnit.SECONDS)) {
            try {
                // 双重检查，防止其他线程已经更新了缓存
                value = cache.get(key);
                if(value != null) {
                    return value;
                }

                value = db.get(key);
                if(value != null) {
                    cache.put(key, value, 30, TimeUnit.MINUTES);
                }
                return value;
            } finally {
                lock.unlock(lockKey);
            }
        } else {
            // 获取锁失败，短暂休眠后重试
            Thread.sleep(50);
            return getDataWithLock(key);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RuntimeException("获取数据中断", e);
    }
}

热点数据永不过期

对于特别热点的数据，可以采用"永不过期"策略，同时后台定时更新缓存。

// 设置缓存永不过期
cache.put(key, value);

// 后台线程定期更新
scheduledExecutor.scheduleAtFixedRate(() -> {
    Object newValue = db.get(key);
    if(newValue != null) {
        cache.put(key, newValue);
    }
}, 30, 30, TimeUnit.MINUTES);

综合解决方案实践

在实际项目中，我们往往需要结合多种策略来应对不同的场景。下面是一个综合解决方案的示例：

public Object getDataComprehensive(String key) {
    // 1. 先查布隆过滤器
    if(!bloomFilter.mightContain(key)) {
        return null;
    }

    // 2. 查缓存
    Object value = cache.get(key);
    if(value != null) {
        return value instanceof NullValue ? null : value;
    }

    // 3. 获取分布式锁
    String lockKey = "lock:" + key;
    try {
        if(lock.tryLock(lockKey, 10, TimeUnit.SECONDS)) {
            try {
                // 4. 双重检查
                value = cache.get(key);
                if(value != null) {
                    return value instanceof NullValue ? null : value;
                }

                // 5. 查询数据库
                value = db.get(key);
                if(value != null) {
                    // 热点数据特殊处理
                    if(isHotKey(key)) {
                        cache.put(key, value);
                        scheduleRefresh(key);
                    } else {
                        cache.put(key, value, 30, TimeUnit.MINUTES);
                    }
                } else {
                    // 空值缓存
                    cache.put(key, new NullValue(), 5, TimeUnit.MINUTES);
                }
                return value;
            } finally {
                lock.unlock(lockKey);
            }
        } else {
            // 6. 获取锁失败，短暂休眠后重试
            Thread.sleep(50);
            return getDataComprehensive(key);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RuntimeException("获取数据中断", e);
    }
}

性能优化与监控

解决缓存穿透和击穿问题后，还需要建立完善的监控体系：

1. 缓存命中率监控：实时监控缓存命中率，发现异常及时报警
2. 热点key识别：通过统计分析识别热点key，提前做好防护
3. 布隆过滤器误判率监控：定期检查布隆过滤器的误判率，适时调整参数
4. 锁竞争监控：记录锁等待时间和竞争情况，优化锁粒度

总结

Java缓存穿透与击穿问题是高并发系统中的常见挑战。通过布隆过滤器、空值缓存、互斥锁、热点数据永不过期等策略的组合使用，可以有效缓解这些问题。实际应用中需要根据业务特点选择合适的解决方案，并建立完善的监控体系，确保系统稳定运行。

记住，没有放之四海而皆准的解决方案，只有最适合当前业务场景的技术选型。希望本文提供的思路能帮助你在实际项目中更好地应对缓存相关的挑战。