Redis缓存穿透、缓存击穿、缓存雪崩的解决方案_redis穿透

区别：

缓存穿透：查询缓存和数据库都不存在的数据，缓存没有，数据库也没有；

缓存击穿：缓存中数据的key过期了，这时候所有请求都到数据库查询，瞬时大量请求击穿数据库

1、缓存穿透

缓存穿透指的查询缓存和数据库中都不存在的数据，这样每次请求直接打到数据库，就好像缓存不存在一样。

缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大。

解决方案：

1. 接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；
2. 缓存空值/默认值 从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短一些，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击
3. 使用布隆过滤器，需要安装redis组件
4. 使用布谷鸟滤器，布谷鸟过滤器是布隆过滤器的升级版，需要安装redis组件
5. 在客户端自行实现布隆过滤算法；可以使用guava包中的或者Redisson包中的。具体使用可参考：https://blog.csdn.net/qq_41125219/article/details/119982158

/**
 * 业务逻辑并没有写错，对于小厂中厂(QPS《=1000)可以使用，但是大厂不行
 * @param id
 * @return
 */
public User findUserById(Integer id) {
    User user = null;
    String key = CACHE_KEY_USER+id;
 
    //1 先从redis里面查询，如果有直接返回结果，如果没有再去查询mysql
    user = (User) redisTemplate.opsForValue().get(key);
 
    if(user == null) {
        //2 redis里面无，继续查询mysql
        user = userMapper.selectById(id);
        if(user == null) {
            //3.1 redis+mysql 都无数据
            //你具体细化，防止多次穿透，我们规定，记录下导致穿透的这个key回写redis
            // 这时也可以将key-value对写为key-null，缓存有效时间可以设置短一些，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击
            return user;
        }else{
            //3.2 mysql有，需要将数据写回redis，保证下一次的缓存命中率
            redisTemplate.opsForValue().set(key,user);
        }
    }
    return user;
}

缓存空值有两大问题：

1. 空值做了缓存，意味着缓存层中存了更多的键，需要更多的内存空间（如果是攻击，问题更严重），比较有效的

   方法是针对这类数据设置一个较短的过期时间，让其自动剔除。

2. 缓存层和存储层的数据会有一段时间窗口的不一致，可能会对业务有一定影响。

   例如过期时间设置为5分钟，如果此时存储层添加了这个数据，那此段时间就会出现缓存层和存储层数据的不一致。

   这时候可以利用消息队列或者其它异步方式清理缓存中的空对象。

布隆过滤器

除了缓存空对象，我们还可以在存储和缓存之前，加一个布隆过滤器，做一层过滤。

布隆过滤器里会保存数据是否存在，如果判断数据不不能再，就不会访问存储。

那布隆过滤器是什么玩意儿？查找它会不会很慢？

布隆过滤器是什么？

不知道你对哈希表了解多少，布隆过滤器是一个类似的东西。

它是一个连续的数据结构，每个存储位存储都是一个bit，即0或者1, 来标识数据是否存在。

存储数据的时时候，使用K个不同的哈希函数将这个变量映射为bit列表的的K个点，把它们置为1。

我们判断缓存key是否存在，同样，K个哈希函数，映射到bit列表上的K个点，判断是不是1：

• 如果全不是1，那么key不存在；
• 如果都是1，也只是表示key可能存在。

至于为什么？因为哈希函数是存在碰撞的可能的。

关于缓存穿透的两种主要解决方案，我们简单对比一下：

2、缓存击穿

缓存击穿指的是一个并发访问量比较大的key在某个时间过期，导致所有的请求直接打在DB上，那么程序在redis找不到数据，就会去数据库里查询，数据库处理大量的请求的同时导致压力瞬间增大，造成压力过大，甚至导致崩溃；

解决方案

1. 设置key值永不过期
2. 将key的过期时间设为随机
3. 使用布隆过滤器或者布谷鸟过滤器
4. 使用分布式锁，当多个key过期时，同一时间只有一个查询请求下发到数据库，其他的key等待一个个地轮流查，就可以避免数据库压力过大的问题；

    // 分布式锁，为了可读性高用 ReentrantLock 代替分布式锁
    static Lock lock = new ReentrantLock();
    
    public String getData(String key ) throws InterruptedException {
        try {
            // 从redis获取值
            String data =  getRedisData(key);
            // 如果key不存在，从数据库查询
            if(null  == data){
                // 尝试获取锁
                if(!lock.tryLock()){
                   // 获取锁失败 ,100ms后在次尝试
                    TimeUnit.MILLISECONDS.sleep(100);
                    data = getData(key);
                }
                // 走到这里表示成功获取锁
 
                // 从myqsl中获取锁
                data = getMysqlData(key);
 
                // 将数据更新到redis
                setDataToRedis(key,value);
            }
            return data;
        } catch (Exception e){
            e.printStackTrace();
            throw e;
        } finally {
            // 解锁
            lock.unlock();
        }
    }

使用synchronized 双端检锁： 

/**
 * 加强补充，避免突然key实现了，打爆mysql，做一下预防，尽量不出现击穿的情况。
 * @param id
 * @return
 */
public User findUserById2(Integer id) {
    User user = null;
    String key = CACHE_KEY_USER+id;
 
    //1 先从redis里面查询，如果有直接返回结果，如果没有再去查询mysql
    user = (User) redisTemplate.opsForValue().get(key);
 
    if(user == null) {
        //2 大厂用，对于高QPS的优化，进来就先加锁，保证一个请求操作，让外面的redis等待一下，避免击穿mysql
        synchronized (UserService.class){
            user = (User) redisTemplate.opsForValue().get(key);
            //3 二次查redis还是null，可以去查mysql了(mysql默认有数据)
            if (user == null) {
                //4 查询mysql拿数据
                user = userMapper.selectById(id);//mysql有数据默认
                if (user == null) {
                    return null;
                }else{
                    //5 mysql里面有数据的，需要回写redis，完成数据一致性的同步工作
                    redisTemplate.opsForValue().setIfAbsent(key,user,7L,TimeUnit.DAYS);
                }
            }
        }
    }
    return user;
}

3、缓存雪崩

缓存雪崩： 当某⼀时刻发⽣⼤规模的缓存失效的情况，例如缓存服务宕机、大量key在同一时间过期，这样的后果就是⼤量的请求进来直接打到DB上，可能导致整个系统的崩溃，称为雪崩。

缓存雪崩如何解决

缓存雪崩是三大缓存问题里最严重的一种，我们来看看怎么预防和处理。

提高缓存可用性

• 集群部署：通过集群来提升缓存的可用性，可以利用Redis本身的Redis Cluster或者第三方集群方案如Codis等。
• 多级缓存：设置多级缓存，第一级缓存失效的基础上，访问二级缓存，每一级缓存的失效时间都不同。

过期时间

• 均匀过期：为了避免大量的缓存在同一时间过期，可以把不同的 key 过期时间随机生成，避免过期时间太过集中。
• 热点数据永不过期。

熔断降级

• 服务熔断：当缓存服务器宕机或超时响应时，为了防止整个系统出现雪崩，暂时停止业务服务访问缓存系统。
• 服务降级：当出现大量缓存失效，而且处在高并发高负荷的情况下，在业务系统内部暂时舍弃对一些非核心的接口和数据的请求，而直接返回一个提前准备好的 fallback（退路）错误处理信息。

总结

一张图总结：

参考：https://www.cnblogs.com/three-fighter/p/15253451.html