Java 缓存穿透与击穿学习的解决方案

xiaoshi 05-30 13 抢沙发

默认

摘要： ...

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