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

阅读量：5288 次

发布时间：2019-06-14

本文共 8445 字，大约阅读时间需要 28 分钟。

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

2019年08月18日 16:34:24 阅读数 1026更多

分类专栏：

本文链接：

1.缓存过期

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

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

一、为了节省内存

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

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

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

二、时效性信息

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

三、用于分布式锁

参考博客：

四、其他需求

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
      
        userIdFilter = BloomFilter.create(Funnels.longFunnel(),expectedInsertions); //填充布隆过滤器 //获取全部用户ID List
       
         idList = MySqlService.getAllId(); List
        
          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
      
        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; } }