缓存雪崩、缓存击穿、缓存穿透详解及解决方案

情书

于 2024-09-27 14:40:13 发布

阅读量350

点赞数 11

文章标签：缓存 java redis

本文链接：https://blog.csdn.net/weixin_48903815/article/details/142593118

版权

缓存雪崩、缓存击穿、缓存穿透详解及解决方案（含Java示例）

在现代的互联网应用中，缓存技术被广泛应用于提升系统的性能和用户体验。但在使用缓存时，经常会遇到一些常见的缓存问题，如缓存雪崩、缓存击穿、缓存穿透。如果不加以合理处理，这些问题可能会导致系统崩溃、性能下降等严重后果。本文将详细讲解这些问题的成因、影响及解决方案，并通过Java代码示例来演示如何解决这些问题。

1. 缓存雪崩

1.1 什么是缓存雪崩？

缓存雪崩指的是由于缓存服务器在同一时间大面积失效或宕机，导致大量请求直接打到数据库，瞬间引发数据库压力激增，甚至导致数据库崩溃。

1.2 造成缓存雪崩的原因

同一时间大量缓存失效：如果缓存设置了相同的过期时间，到了某个时间点，大量缓存同时失效，所有请求直接打到数据库，造成数据库压力骤增。
缓存服务器宕机：缓存服务器因故障无法提供服务，导致请求全部直接打到数据库。

1.3 解决方案

缓存过期时间设置为随机值：
- 不要让所有缓存同时过期，可以通过设置缓存的过期时间为随机值来避免。
- 例如，缓存的过期时间 TTL 设为一个基准值加上一个随机的时间偏移量。
加固缓存系统：
- 使用分布式缓存架构，避免单点故障。常用的分布式缓存有Redis Cluster、Memcached等。
- 为缓存服务配置备份节点和集群架构，防止因缓存宕机引发系统崩溃。
限流降级：
- 在缓存失效时，对请求进行限流，防止过多请求涌入数据库。可以通过限流器（如漏桶算法、令牌桶算法）等方式来控制请求量。
- 同时，在缓存不可用时可以返回一些默认值或者降级的数据。

1.4 Java 示例

import java.util.Random;
import java.util.concurrent.TimeUnit;

public class CacheService {
    private static final Random random = new Random();

    // 模拟缓存设置
    public void setCache(String key, Object value) {
        // 过期时间设为基准时间10分钟，加上随机0~5分钟的偏移，避免同时过期
        int baseExpireTime = 10 * 60;  // 10分钟
        int randomExpireTime = random.nextInt(5 * 60);  // 随机0~5分钟
        int expireTime = baseExpireTime + randomExpireTime;

        // 假设使用某缓存工具库
        Cache.put(key, value, expireTime, TimeUnit.SECONDS);
    }

    // 模拟缓存的获取和回源逻辑
    public Object getCache(String key) {
        Object cacheValue = Cache.get(key);
        if (cacheValue == null) {
            synchronized (this) {
                // 双重检测锁，防止缓存击穿
                cacheValue = Cache.get(key);
                if (cacheValue == null) {
                    // 从数据库查询数据
                    cacheValue = queryDatabase(key);
                    setCache(key, cacheValue);
                }
            }
        }
        return cacheValue;
    }

    private Object queryDatabase(String key) {
        // 模拟数据库查询
        return "DataFromDatabase";
    }
}

2. 缓存击穿

2.1 什么是缓存击穿？

缓存击穿是指某个热点数据在缓存中失效的瞬间，大量的并发请求同时访问该数据，由于该数据在缓存中失效，大量请求同时打到数据库，造成数据库压力骤增。这种情况通常发生在热点数据或访问频繁的数据上。

2.2 解决方案

互斥锁（Mutex）机制：
- 当缓存失效时，通过加锁的方式保证只有一个线程去查询数据库并更新缓存，其他线程等待缓存更新完成后再获取数据。
预加载缓存：
- 对一些热点数据提前加载，并定期刷新缓存，防止缓存失效。
使用不过期的缓存：
- 对于极为重要的热点数据，可以设置其缓存永不过期，同时后台启动线程定期刷新该缓存。

2.3 Java 示例

public class CacheServiceWithMutex {
    
    // 模拟缓存获取和回源逻辑，并加锁防止缓存击穿
    public Object getCacheWithLock(String key) {
        Object cacheValue = Cache.get(key);
        if (cacheValue == null) {
            synchronized (this) {
                cacheValue = Cache.get(key);
                if (cacheValue == null) {
                    // 加锁后，从数据库查询
                    cacheValue = queryDatabase(key);
                    setCache(key, cacheValue);
                }
            }
        }
        return cacheValue;
    }

    private void setCache(String key, Object value) {
        // 设置过期时间为10分钟，假设使用某缓存工具库
        Cache.put(key, value, 10, TimeUnit.MINUTES);
    }

    private Object queryDatabase(String key) {
        // 模拟数据库查询
        return "DataFromDatabase";
    }
}

3. 缓存穿透

3.1 什么是缓存穿透？

缓存穿透是指客户端频繁访问一些根本不存在的缓存数据，由于缓存中没有这些数据的记录，每次请求都直接打到数据库，导致数据库压力增大。这通常是由于用户输入非法或恶意构造的请求引发的。

3.2 解决方案

缓存空值：
- 当查询一个不存在的key时，将空结果也写入缓存，并设置一个较短的过期时间。下次再遇到相同的请求时，可以直接返回缓存中的空值，避免再次查询数据库。
布隆过滤器（Bloom Filter）：
- 在查询缓存和数据库之前，利用布隆过滤器来快速判断某个key是否存在。如果布隆过滤器判定该key不存在，则直接返回，不必查询缓存或数据库。
参数校验：
- 在系统前端或者应用层对请求的参数进行有效性验证，过滤掉明显无效或恶意的请求。

3.3 Java 示例

public class CacheServiceWithBloomFilter {
    
    private BloomFilter<String> bloomFilter;

    public CacheServiceWithBloomFilter() {
        // 初始化布隆过滤器
        bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 100000, 0.01);
    }

    // 模拟缓存获取，并通过布隆过滤器防止缓存穿透
    public Object getCacheWithBloomFilter(String key) {
        // 使用布隆过滤器判断key是否可能存在
        if (!bloomFilter.mightContain(key)) {
            // 布隆过滤器判定key不存在，直接返回null
            return null;
        }

        Object cacheValue = Cache.get(key);
        if (cacheValue == null) {
            synchronized (this) {
                cacheValue = Cache.get(key);
                if (cacheValue == null) {
                    // 从数据库查询
                    cacheValue = queryDatabase(key);
                    if (cacheValue == null) {
                        // 缓存空值，防止再次穿透
                        setCache(key, "");
                    } else {
                        setCache(key, cacheValue);
                    }
                }
            }
        }
        return cacheValue;
    }

    private void setCache(String key, Object value) {
        // 设置过期时间为5分钟，假设使用某缓存工具库
        Cache.put(key, value, 5, TimeUnit.MINUTES);
    }

    private Object queryDatabase(String key) {
        // 模拟数据库查询
        return null;  // 模拟查询不到
    }
}