深入理解Redis缓存设计与性能优化

缓存设计

缓存穿透

缓存穿透是指查询一个根本不存在的数据， 缓存层和存储层都不会命中， 通常出于容错的考虑， 如果从存储层查不到数据则不写入缓存层。缓存穿透将导致不存在的数据每次请求都要到存储层去查询， 失去了缓存保护后端存储的意义。 造成缓存穿透的基本原因有两个：

第一， 自身业务代码或者数据出现问题。

第二， 一些恶意攻击、 爬虫等造成大量空命中。

缓存穿透问题解决方案：

1、缓存空对象

String get(String key) { 

2 // 从缓存中获取数据 
​
3 String cacheValue = cache.get(key); 
​
4 // 缓存为空 
​
5 if (StringUtils.isBlank(cacheValue)) { 
​
6 // 从存储中获取 
​
7 String storageValue = storage.get(key); 
​
8 cache.set(key, storageValue); 
​
9 // 如果存储数据为空， 需要设置一个过期时间(300秒)10 if (storageValue == null) { 
​
11 cache.expire(key, 60 * 5); 
​
12 } 
​
13 return storageValue; 
​
14 } else { 
​
15 // 缓存非空 
​
16 return cacheValue; 
​
17 } 
​
18 } 

2、布隆过滤器

对于恶意攻击，向服务器请求大量不存在的数据造成的缓存穿透，还可以用布隆过滤器先做一次过滤，对于不 存在的数据布隆过滤器一般都能够过滤掉，不让请求再往后端发送。当布隆过滤器说 某个值存在时，这个值可能不存在；当它说不存在时，那就肯定不存在。

布隆过滤器就是一个大型的位数组和几个不一样的无偏 hash 函数。所谓无偏就是能够把元素的 hash 值算得比较均匀。向布隆过滤器中添加 key 时，会使用多个 hash 函数对 key 进行 hash 算得一个整数索引值然后对位数组长度 进行取模运算得到一个位置，每个 hash 函数都会算得一个不同的位置。再把位数组的这几个位置都置为 1 就 完成了 add 操作。向布隆过滤器询问 key 是否存在时，跟 add 一样，也会把 hash 的几个位置都算出来，看看位数组中这几个位 置是否都为 1，只要有一个位为 0，那么说明布隆过滤器中这个key 不存在。如果都是 1，这并不能说明这个key 就一定存在，只是极有可能存在，因为这些位被置为 1 可能是因为其它的 key 存在所致。如果这个数组，比较稀疏，这个概率就会很大，如果这个位数组比较拥挤，这个概率就会降低。 这种方法适用于数据命中不高、 数据相对固定、 实时性低（通常是数据集较大） 的应用场景， 代码维护较为复杂， 但是缓存空间占用很少。 可以用redisson实现布隆过滤器，引入依赖：

1 <dependency> 
​
2 <groupId>org.redisson</groupId> 
​
3 <artifactId>redisson</artifactId> 
​
4 <version>3.6.5</version> 
​
5 </dependency> 

示例伪代码：

3 import org.redisson.Redisson;4 import org.redisson.api.RBloomFilter; 
​
5 import org.redisson.api.RedissonClient; 
​
6 import org.redisson.config.Config; 
​
7
​
8 public class RedissonBloomFilter { 
​
9
​
10 public static void main(String[] args) { 
​
11 Config config = new Config(); 
​
12 config.useSingleServer().setAddress("redis://localhost:6379"); 
​
13 //构造Redisson 
​
14 RedissonClient redisson = Redisson.create(config); 
​
15
​
16 RBloomFilter<String> bloomFilter = redisson.getBloomFilter("nameList"); 
​
17 //初始化布隆过滤器：预计元素为100000000L,误差率为3%,根据这两个参数会计算出底层的bit数组大小 
​
18 bloomFilter.tryInit(100000000L,0.03); 
​
19 //将zhuge插入到布隆过滤器中 
​
20 bloomFilter.add("zhuge"); 
​
21
​
22 //判断下面号码是否在布隆过滤器中 
​
23 System.out.println(bloomFilter.contains("zhangsan"));//false 
​
24 System.out.println(bloomFilter.contains("lisi"));//false 
​
25 System.out.println(bloomFilter.contains("wangwu"));//true 
​
26 } 
​
27 } 

使用布隆过滤器需要把所有数据提前放入布隆过滤器，并且在增加数据时也要往布隆过滤器里放，布隆过滤器缓存过滤伪代码：

1 //初始化布隆过滤器 
​
2 RBloomFilter<String> bloomFilter = redisson.getBloomFilter("nameList"); 
​
3 //初始化布隆过滤器：预计元素为100000000L,误差率为3% 
​
4 bloomFilter.tryInit(100000000L,0.03); 
​
5
​
6 //把所有数据存入布隆过滤器 
​
7 void init(){ 
​
8 for (String key: keys) { 
​
9 bloomFilter.put(key); 
​
10 } 
​
11 } 
​
12
​
13 String get(String key) { 
​
14 // 从布隆过滤器这一级缓存判断下key是否存在 
​
15 Boolean exist = bloomFilter.contains(key); 
​
16 if(!exist){ 
​
17 return ""; 
​
18 } 
​
19 // 从缓存中获取数据 
​
20 String cacheValue = cache.get(key); 
​
21 // 缓存为空22 if (StringUtils.isBlank(cacheValue)) { 
​
23 // 从存储中获取 
​
24 String storageValue = storage.get(key); 
​
25 cache.set(key, storageValue); 
​
26 // 如果存储数据为空， 需要设置一个过期时间(300秒) 
​
27 if (storageValue == null) { 
​
28 cache.expire(key, 60 * 5); 
​
29 } 
​
30 return storageValue; 
​
31 } else { 
​
32 // 缓存非空 
​
33 return cacheValue; 
​
34 } 
​
35 } 

注意：布隆过滤器不能删除数据，如果要删除得重新初始化数据。

缓存失效(击穿)

由于大批量缓存在同一时间失效可能导致大量请求同时穿透缓存直达数据库，可能会造成数据库瞬间压力过大 甚至挂掉，对于这种情况我们在批量增加缓存时最好将这一批数据的缓存过期时间设置为一个时间段内的不同时间。

示例伪代码：

1 String get(String key) { 
​
2 // 从缓存中获取数据 
​
3 String cacheValue = cache.get(key); 
​
4 // 缓存为空 
​
5 if (StringUtils.isBlank(cacheValue)) { 
​
6 // 从存储中获取 
​
7 String storageValue = storage.get(key); 
​
8 cache.set(key, storageValue); 
​
9 //设置一个过期时间(300到600之间的一个随机数) 
​
10 int expireTime = new Random().nextInt(300) + 300; 
​
11 if (storageValue == null) { 
​
12 cache.expire(key, expireTime); 
​
13 } 
​
14 return storageValue; 
​
15 } else { 
​
16 // 缓存非空 
​
17 return cacheValue; 
​
18 } 
​
19 } 

缓存雪崩

缓存雪崩指的是缓存层支撑不住或宕掉后， 流量会像奔逃的野牛一样， 打向后端存储层。由于缓存层承载着大量请求， 有效地保护了存储层， 但是如果缓存层由于某些原因不能提供服务(比如超大并发过来，缓存层支撑不住，或者由于缓存设计不好，类似大量请求访问bigkey，导致缓存能支撑的并发急剧下降)， 于是大量请求都会打到存储层， 存储层的调用量会暴增， 造成存储层也会级联宕机的情况。预防和解决缓存雪崩问题，可以从以下三个方面进行着手：

1） 保证缓存层服务高可用性，比如使用Redis Sentinel或Redis Cluster。

2） 依赖隔离组件为后端限流熔断并降级。比如使用Sentinel或Hystrix限流降级组件。比如服务降级，我们可以针对不同的数据采取不同的处理方式。当业务应用访问的是非核心数据（例如电商商品属性，用户信息等）时，暂时停止从缓存中查询这些数据，而是直接返回预定义的默认降级信息、空值或是错误提示信息；当业务应用访问的是核心数据（例如电商商品库存）时，仍然允许查询缓存，如果缓存缺失，也可以继续通过数据库读取。

3） 提前演练。 在项目上线前， 演练缓存层宕掉后， 应用以及后端的负载情况以及可能出现的问题， 在此基础上做一些预案设定。

热点缓存key重建优化

开发人员使用“缓存+过期时间”的策略既可以加速数据读写， 又保证数据的定期更新， 这种模式基本能够满足绝大部分需求。 但是有两个问题如果同时出现， 可能就会对应用造成致命的危害：当前key是一个热点key（例如一个热门的娱乐新闻），并发量非常大。重建缓存不能在短时间完成， 可能是一个复杂计算， 例如复杂的SQL、 多次IO、 多个依赖等。在缓存失效的瞬间， 有大量线程来重建缓存， 造成后端负载加大， 甚至可能会让应用崩溃。要解决这个问题主要就是要避免大量线程同时重建缓存。 我们可以利用互斥锁来解决，此方法只允许一个线程重建缓存， 其他线程等待重建缓存的线程执行完， 重新从 缓存获取数据即可。

示例伪代码：

1 String get(String key) { 
​
2 // 从Redis中获取数据 
​
3 String value = redis.get(key); 
​
4 // 如果value为空， 则开始重构缓存 
​
5 if (value == null) { 
​
6 // 只允许一个线程重建缓存， 使用nx， 并设置过期时间ex 
​
7 String mutexKey = "mutext:key:" + key; 
​
8 if (redis.set(mutexKey, "1", "ex 180", "nx")) { 
​
9 // 从数据源获取数据 
​
10 value = db.get(key); 
​
11 // 回写Redis， 并设置过期时间 
​
12 redis.setex(key, timeout, value); 
​
13 // 删除key_mutex 
​
14 redis.delete(mutexKey); 
​
15 }// 其他线程休息50毫秒后重试 
​
16 else { 
​
17 Thread.sleep(50); 
​
18 get(key); 
​
19 } 
​
20 } 
​
21 return value; 
​
22 } 

缓存与数据库双写不一致：

在大并发下，同时操作数据库与缓存会存在数据不一致性问题

1、双写不一致情况

2、读写并发不一致

解决方案：

1、对于并发几率很小的数据(如个人维度的订单数据、用户数据等)，这种几乎不用考虑这个问题，很少会发生缓存不一致，可以给缓存数据加上过期时间，每隔一段时间触发读的主动更新即可。

2、就算并发很高，如果业务上能容忍短时间的缓存数据不一致(如商品名称，商品分类菜单等)，缓存加上过期时间依然可以解决大部分业务对于缓存的要求。

3、如果不能容忍缓存数据不一致，可以通过加分布式读写锁保证并发读写或写写的时候按顺序排好队，读读的

时候相当于无锁。

4、也可以用阿里开源的canal通过监听数据库的binlog日志及时的去修改缓存，但是引入了新的中间件，增加 了系统的复杂度。

总结：

以上我们针对的都是读多写少的情况加入缓存提高性能，如果写多读多的情况又不能容忍缓存数据不一致，那就没必要加缓存了，可以直接操作数据库。当然，如果数据库抗不住压力，还可以把缓存作为数据读写的主存储，异步将数据同步到数据库，数据库只是作为数据的备份。放入缓存的数据应该是对实时性、一致性要求不是很高的数据。切记不要为了用缓存，同时又要保证绝对的一致性做大量的过度设计和控制，增加系统复杂性！

Redis对于过期键有三种清除策略：

1. 被动删除：当读/写一个已经过期的key时，会触发惰性删除策略，直接删除掉这个过期key
2. 主动删除：由于惰性删除策略无法保证冷数据被及时删掉，所以Redis会定期主动淘汰一批已过期的key
3. 当前已用内存超过maxmemory限定时，触发主动清理策略

主动清理策略在Redis 4.0 之前一共实现了 6 种内存淘汰策略，在 4.0 之后，又增加了 2 种策略，总共8种：

a) 针对设置了过期时间的key做处理：

1. volatile-ttl：在筛选时,会针对设置了过期时间的键值对，根据过期时间的先后进行删除，越早过期的越先删除。
2. volatile-random：就像它的名称一样，在设置了过期时间的键值对中，进行随机删除。
3. volatile-lru：会使用 LRU 算法筛选设置了过期时间的键值对删除。
4. volatile-lfu：会使用 LFU 算法筛选设置了过期时间的键值对删除。

b) 针对所有的key做处理：

1. allkeys-random：从所有键值对中随机选择并删除数据。
2. allkeys-lru：使用 LRU 算法在所有数据中进行筛选删除。
3. allkeys-lfu：使用 LFU 算法在所有数据中进行筛选删除。

c) 不处理：

1. noeviction：不会剔除任何数据，拒绝所有写入操作并返回客户端错误信息"(error)

OOM command not allowed when used memory"，此时Redis只响应读操作。

LRU 算法 （Least Recently Used* ，最近最少使用）*

淘汰很久没被访问过的数据，以最近一次访问时间作为参考。

LFU 算法* *（Least Frequently Used ，最不经常使用）

淘汰最近一段时间被访问次数最少的数据，以次数作为参考。 当存在热点数据时，LRU的效率很好，但偶发性的、周期性的批量操作会导致LRU命中率急剧下降，缓存污染情况比较 严重。这时使用LFU可能更好点。根据自身业务类型，配置好maxmemory-policy(默认是noeviction)，推荐使用volatile-lru。如果不设置最大内存，当 Redis 内存超出物理内存限制时，内存的数据会开始和磁盘产生频繁的交 换 (swap)，会让 Redis 的性能急剧下降。当Redis运行在主从模式时，只有主结点才会执行过期删除策略，然后把删除操作”del key”同步到从结点删除数据。

作者：小张架构之路

出处：
https://juejin.cn/post/7101483618790277150