Redis缓存设计的问题

多级缓存架构

缓存设计

缓存穿透

缓存穿透是指查询一个根本不存在的数据， 缓存层和存储层都不会命中， 通常出于容错的考虑， 如果从存储

层查不到数据则不写入缓存层。

缓存穿透将导致不存在的数据每次请求都要到存储层去查询， 失去了缓存保护后端存储的意义。

造成缓存穿透的基本原因有两个：

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

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

缓存穿透问题解决方案：

 

1、缓存空对象

 

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 >

示例伪代码：

1 package com . redisson ;

2

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 ( 100000000 L , 0.03 );

19 // 将 zhuge 插入到布隆过滤器中

20 bloomFilter . add ( "zhuge" );

21

22 // 判断下面号码是否在布隆过滤器中

23 System . out . println ( bloomFilter . contains ( "guojia" )); //false

24 System . out . println ( bloomFilter . contains ( "baiqi" )); //false

25 System . out . println ( bloomFilter . contains ( "zhuge" )); //true

26 }

27 }

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

缓存过滤伪代码：

1 // 初始化布隆过滤器

2 RBloomFilter < String > bloomFilter = redisson . getBloomFilter ( "nameList" );

3 // 初始化布隆过滤器：预计元素为 100000000L, 误差率为 3%

4 bloomFilter . tryInit ( 100000000 L , 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日志及时的去修改缓存，但是引入了新的中间件，增加

了系统的复杂度。

 

5、延迟双删，写入删除之后设置一个sleep时间再进行一次删除，一般不推荐，对系统性能影响

 

总结：

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