Redis: 缓存过期、缓存雪崩、缓存穿透、缓存击穿(热点)、缓存并发(热点)、多级缓存、布隆过滤器

最新推荐文章于 2023-08-24 15:00:00 发布

置顶 hanchao5272

最新推荐文章于 2023-08-24 15:00:00 发布

阅读量5.8k

点赞数 42

分类专栏： Redis 分布式文章标签： redis 缓存雪崩缓存穿透多级缓存

本文链接：https://blog.csdn.net/hanchao5272/article/details/99706189

版权

Redis 同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

分布式

6 篇文章 1 订阅

订阅专栏

1.缓存过期

缓存过期：在使用缓存时，可以通过TTL(Time To Live)设置失效时间，当TTL为0时，缓存失效。

为什么要设置缓存的过期时间呢？

一、为了节省内存

例如，在缓存中存放了近3年的10亿条博文数据，但是经常被访问的可能只有10万条，其他的可能几个月才访问一次。

那么，就没有必要让所有的博文数据长期存在于缓存中。

设置一个过期时间比方说7天，超过7天未被访问的博文数据将会自动失效，如此节省大量内存。

二、时效性信息

有些信息具有时效性，设置过期时间非常合适。例如：游戏中的发言间隔为10秒钟，可以通过缓存实现。

三、用于分布式锁

参考博客：Redis: 分布式锁的官方算法RedLock以及Java版本实现库Redisson

四、其他需求

2.缓存雪崩

缓存雪崩：某一时间段内，缓存服务器挂掉，或者大量缓存失效，导致大量请求直接访问数据库，给数据库造成极大压力，甚至宕机，严重时引起整个系统的崩溃。

解决办法：

数据库访问加锁
随机过期时间
定时刷新缓存
缓存刷新标记
多级缓存

2.1.数据库访问加锁

因为短时间内大量请求访问数据库，导致后续影响，那么限制数据库的访问量不就行了吗？

限制数据库访问量的方法有很多，对数据库的访问进行加锁就是一种最直接的方式。

下面分别给出的伪代码：

    /**
     * 用于加锁的对象
     */
    private static final byte[] LOCK_OBJ = new byte[0];

    /**
     * 获取商品信息
     */
    public String getGoodsByLock(String key) {
        //获取缓存值
        String value = RedisService.get(key);

        // 如果缓存有值，就直接取出来即可
        if (value != null) {
            return value;
        } else {
            //对数据库的访问进行加锁限制
            synchronized (LOCK_OBJ) {
                value = RedisService.get(key);
                if (value != null) {
                    return value;
                } else {
                    //访问数据库
                    value = MySqlService.select(key);
                    //缓存刷新
                    RedisService.set(key, value, 10);
                }
            }
            return value;
        }
    }

分析：加锁会产生线程阻塞，导致用户长时间进行等待，体验不好，只适合并发量小的场景。

2.2.随机过期时间

缓存雪崩的主要原因是，短时间内大量缓存失效造成的，那么避免大量缓存同时失效不就行了吗？

避免大量缓存失效的最直接方法就是给缓存设置不同的过期时间。例如，原定失效时间30分钟，修改为失效时间在30~35分钟之内随机。

下面给出一种获取随机失效时间的简单实现作为参考：

    /**
     * 获取随机失效时间
     *
     * @param originExpire 原定失效时间
     * @param randomScope  最大随机范围
     * @return 随机失效时间
     */
    public static Long getRandomExpire(Long originExpire, Long randomScope) {
        return originExpire + RandomUtils.nextLong(0, randomScope);
    }

**分析：**随机过期时间，虽然实现简单，但是并不能完全避免大量缓存的同时过期。

例如：大量缓存的过期时间设置在30~35分钟，但是无论如何随机，这些缓存经过40分钟后，都会过期。

造成如此结果的原因可能有很多，例如：过期时间设计不合理等。

2.3.定时刷新缓存

避免大量缓存失效的另一种策略就是：开发额外的服务，定时刷新缓存。

这样做，虽然能够保证缓存的失效，但是有个弊端：缓存可能多种多样，每种缓存都需要开发对应的定时刷新服务，相当麻烦。

2.4.缓存刷新标记

缓存失效标记，其实也是一种缓存刷新策略，只不过它更加通用化，无需针对每种缓存进行定制开发。

**思路：**不仅存储缓存数据，而且存储是否需要刷新的标记。

缓存刷新标记：

标记数据是否应该被刷新，如果存在则表示数据无需刷新，反之则表示需要刷新。
缓存刷新标记的过期时间要比缓存本身的过期时间要短，这样才能起到提前刷新的效果。可以设置为1:2，或者1:1.5。

下面给出伪代码：

    /**
     * 线程池：用于异步刷新缓存
     */
    private static ExecutorService executorService = Executors.newCachedThreadPool();
    /**
     * 缓存刷新标记后缀
     */
    public static final String REFRESH_SUFFIX = "_r";

    /**
     * 获取缓存刷新标记的key
     */
    public String getRefreshKey(String key) {
        return key + REFRESH_SUFFIX;
    }

    /**
     * 判断无需刷新: 刷新标记存在，则表示不需要刷新
     */
    public boolean notNeedRefresh(String key) {
        return RedisService.containsKey(key + REFRESH_SUFFIX);
    }

    /**
     * 获取商品信息
     */
    public String getGoods(String key) {
        //获取缓存值
        String value = RedisService.get(key);

        //过期时间
        Long expire = 10L;

        //如果无需刷新，则直接返回缓存值
        if (notNeedRefresh(key)) {
            //理论上：如果缓存刷新标记存在，则缓存必存在，所以可以直接返回
            return value;
        } else {
            //如果需要刷新，则重置缓存刷新标记的过期时间
            RedisService.set(getRefreshKey(key), "1", expire / 2);

            //如果缓存有值，就直接返回即可
            if (value != null) {
                //因为有值，所以可以异步刷新缓存
                executorService.submit(() -> {
                    //访问数据库
                    String newValue = MySqlService.select(key);
                    //缓存刷新
                    RedisService.set(key, newValue, expire);
                });

                return value;
            } else {
                //因为无值，所以还是要同步刷新缓存
                value = MySqlService.select(key);
                //缓存刷新
                RedisService.set(key, value, expire);

                return value;
            }
        }
    }

分析：刷新标记本身也存在大量失效的可能。

2.5.多级缓存

所谓多级缓存，就是设置多个层级的缓存。

例如：

本地缓存 + 分布式缓存构成二级缓存，本地缓存作为第一级缓存，分布式缓存作为第二级缓存。
本地缓存可以通过多种技术实现，如：Ehcache、Caffeine等。
分布式缓存一般采用Redis实现。
由于本地缓存会占用JVM的heap空间，所以本地缓存中存放少量关键信息，其他的缓存信息存放在分布式缓存中。

下面是一个二级缓存示例的伪代码：

    /**
     * 是否使用一级缓存
     */
    @Setter
    private boolean useFirstCache;

    /**
     * 查询商品信息
     */
    public String getGoods(String key) {
        String value;

        //如果使用一级缓存，则首先从一级缓存中获取数据
        if (useFirstCache) {
            value = LocalCacheService.get(key);
            if (value != null) {
                return value;
            }
        }

        //如果一级缓存中无值，则查询二级缓存
        value = RedisCacheService.get(key);
        if (value != null) {
            return value;
        } else {
            //如果二级缓存中也无值，则查询数据库
            value = MySqlService.select(key);
            //缓存刷新
            RedisCacheService.set(key, value, 10);
            return value;
        }
    }

3.缓存穿透

缓存穿透：大量请求查询本就不存在的数据，由于这些数据在缓存中肯定不存在，所以会直接绕过缓存，直接访问数据库，给数据库造成极大压力，甚至宕机，严重时引起整个系统的崩溃。

举例：有些黑客恶意攻击网站，制造大量请求访问不存在的缓存，直接搞垮网站。

解决办法：

空值缓存
布隆过滤器

3.1.空值缓存

空值缓存：查询数据库为空时，仍然把空设置成一种默认值进行缓存，这样后续请求继续请求这个key时，知道值不存在就不会去数据库查询了。

下面给出示例伪代码:

    /**
     * 缓存空值
     */
    public static final String NULL_CACHE = "_";

    /**
     * 获取商品信息
     */
    public String getGoodsByLock(String key) {
        //获取缓存值
        String value = RedisCacheService.get(key);

        //如果缓存有值
        if (value != null) {
            //如果缓存的是空值，则直接返回空，无需查询数据库
            if (NULL_CACHE.equals(value)) {
                return null;
            } else {
                return value;
            }
        } else {
            //访问数据库
            value = MySqlService.select(key);
            //如果数据库有值，则直接返回
            if (value != null) {
                //缓存刷新
                RedisCacheService.set(key, value, 10);
                return value;
            } else {
                //如果数据库无值，则设置空值缓存
                RedisCacheService.set(key, NULL_CACHE, 5);
                return null;
            }
        }
    }

缺点：

有可能设置空值缓存之后数据又有值了，这时如果无正确的刷新策略，会导致数据不一致，所以空值失效时间不要设置太长，例如5分钟即可。
空值缓存虽然能够避免缓存穿透，但是如果存在大量请求不存在，则会储存大量空值缓存，消耗较多内存。

3.2.布隆过滤器

什么是布隆过滤器？

布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的bit数组和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多，缺点是有一定的误识别率和删除困难。

简单理解布隆过滤器

首先，我们定义一个bit数组，每个元素只占1byte。

然后，在存放每个元素时，分表对其进行若干次(例如3次)哈希函数计算，将每个哈希结果对应的bit数组元素置为1。
最后，判断一个元素是否在bit数组中，只需对其同样进行若干次(例如3次)哈希函数计算，如果计算结果对应的bit数组元素都为1，则可以判断：这个元素可能存在与bit数组中；如果有任一个哈希结果对应的元素不为1，则可以判断：这个元素必定不存在于bit数组中。

关于布隆过滤器的实现有多种，常用的有guava包和redis。

guava版本的布隆过滤器

这里给出guava版本布隆过滤器的简单使用：

        //定义布隆过滤器的期望填充数量
        Integer expectedInsertions = 100;
        //定义布隆过滤器：默认情况下，使用5个哈希函数已保证3%的误差率。
        BloomFilter<Long> userIdFilter = BloomFilter.create(Funnels.longFunnel(),expectedInsertions);

        //填充布隆过滤器
        //获取全部用户ID List<Long> idList = MySqlService.getAllId();
        List<Long> idList = Lists.newArrayList(521L,1314L,9527L,3721L);
        if (CollectionUtils.isNotEmpty(idList)){
            idList.forEach(userIdFilter::put);
        }

        //通过布隆过滤器判断数据是否存在
        log.info("521是否存在：{}",userIdFilter.mightContain(521L));
        log.info("125是否存在：{}",userIdFilter.mightContain(125L));

运行结果：

 INFO traceId: pers.hanchao.basiccodeguideline.redis.bloom.BloomFilterDemo:33 - 521是否存在：true 
 INFO traceId: pers.hanchao.basiccodeguideline.redis.bloom.BloomFilterDemo:34 - 125是否存在：false

**缺点：**是一种本地布隆过滤器，基于JVM内存，会占用heap空间，重启失效，不适用与分布式场景，不适用与大批量数据。

Redis版本的布隆过滤器

基于Redis的布隆过滤器实现，目前本人也并未深入了解，这里暂时就不班门弄斧了，各位可自行了解。

4.缓存热点并发

缓存热点并发： 大量请求查询一个热点Key，此key过期的瞬间来不及更新，导致大量请求直接访问数据库，给数据库造成极大压力，甚至宕机，严重时引起整个系统的崩溃。

解决办法：

缓存重建加锁
热点key不过期：重建缓存期间，数据不一致。
多级缓存。

4.1.缓存重建加锁

与章节2.1.数据库访问加锁的思路类似，伪代码如下：

    /**
     * 用于加锁的对象
     */
    private static final byte[] LOCK_OBJ = new byte[0];

    /**
     * 通过某种手段（如配置中心等）判断一个值是热点key。这里为了示例直接硬编码
     */
    private Set<String> hotKeySet = Sets.newHashSet("521", "1314");

    /**
     * 获取商品信息
     */
    public String getGoodsByLock(String key) {
        //获取缓存值
        String value = RedisCacheService.get(key);

        // 如果缓存有值，就直接取出来即可
        if (value != null) {
            return value;
        } else {
            //如果是热点key，则对缓存重建过程进行加锁
            if (hotKeySet.contains(key)) {
                //对缓存重建过程进行加锁限制
                synchronized (LOCK_OBJ) {
                    value = RedisCacheService.get(key);
                    if (value != null) {
                        return value;
                    } else {
                        //访问数据库
                        value = MySqlService.select(key);
                        //缓存刷新
                        RedisCacheService.set(key, value, 10);
                    }
                }
            } else {
                //如果是普通Key，无需对缓存重建加锁
                value = MySqlService.select(key);
                //缓存刷新
                RedisCacheService.set(key, value, 10);
            }

            return value;
        }
    }