REDIS缓存穿透，缓存击穿，缓存雪崩

一、缓存处理流程

      前台请求，后台先从缓存中取数据，取到直接返回结果，取不到时从数据库中取，数据库取到更新缓存，并返回结果，数据库也没取到，那直接返回空结果。

二、缓存穿透

缓存穿透是指查询一个一定不存在的数据，由于缓存是不命中时需要从数据库查询，查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到数据库去查询，造成缓存穿透。在流量大时，可能DB就挂掉了，要是有人利用不存在的key频繁攻击我们的应用，这就是漏洞。

 解决方案：

1）有很多种方法可以有效地解决缓存穿透问题，最常见的则是采用布隆过滤器BloomFilter，将所有可能存在的数据哈希到一个足够大的bitmap中，一个一定不存在的数据会被这个bitmap拦截掉，从而避免了对底层数据库的查询压力。BloomFilter 的特点是存在性检测，如果 BloomFilter 中不存在，那么数据一定不存在；如果 BloomFilter 中存在，实际数据也有可能会不存在。非常适合解决这类的问题。

2）另外也有一个更为简单粗暴的方法，如果一个查询返回的数据为空（不管是数据不存在，还是系统故障），仍然把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

//伪代码 public object GetProductListNew() {     int cacheTime = 30;     String cacheKey = "product_list";       String cacheValue = CacheHelper.Get(cacheKey);     if (cacheValue != null) {         return cacheValue;     }       cacheValue = CacheHelper.Get(cacheKey);     if (cacheValue != null) {         return cacheValue;     } else {         //数据库查询不到，为空         cacheValue = GetProductListFromDB();         if (cacheValue == null) {             //如果发现为空，设置个默认值，也缓存起来             cacheValue = string.Empty;         }         CacheHelper.Add(cacheKey, cacheValue, cacheTime);         return cacheValue;     } }

三、缓存雪崩

缓存雪崩是指在设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效，导致所有的查询都落在数据库上，造成了缓存雪崩。

解决方案：

1）在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

加锁排队，伪代码如下：   //伪代码 public object GetProductListNew() {     int cacheTime = 30;     String cacheKey = "product_list";     String lockKey = cacheKey;       String cacheValue = CacheHelper.get(cacheKey);     if (cacheValue != null) {         return cacheValue;     } else {         synchronized(lockKey) {             cacheValue = CacheHelper.get(cacheKey);             if (cacheValue != null) {                 return cacheValue;             } else {               //这里一般是sql查询数据                 cacheValue = GetProductListFromDB();                 CacheHelper.Add(cacheKey, cacheValue, cacheTime);             }         }         return cacheValue;     } }

2）可以通过缓存reload机制，预先去更新缓存，在即将发生大并发访问前手动触发加载缓存。

3）不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

随机值伪代码：   //伪代码 public object GetProductListNew() {     int cacheTime = 30;     String cacheKey = "product_list";     //缓存标记     String cacheSign = cacheKey + "_sign";       String sign = CacheHelper.Get(cacheSign);     //获取缓存值     String cacheValue = CacheHelper.Get(cacheKey);     if (sign != null) {         return cacheValue; //未过期，直接返回     } else {         CacheHelper.Add(cacheSign, "1", cacheTime);         ThreadPool.QueueUserWorkItem((arg) -> {       //这里一般是 sql查询数据             cacheValue = GetProductListFromDB();           //日期设缓存时间的2倍，用于脏读           CacheHelper.Add(cacheKey, cacheValue, cacheTime * 2);                         });         return cacheValue;     } }

4）做二级缓存，或者双缓存策略。A1为原始缓存，A2为拷贝缓存，A1失效时，可以访问A2，A1缓存失效时间设置为短期，A2设置为长期。

四、缓存击穿

对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题：缓存被“击穿”的问题，这个和缓存雪崩的区别在于这里针对某一key缓存，前者则是很多key。 
缓存在某个时间点过期的时候，恰好在这个时间点对这个Key有大量的并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。

解决方案：设置热点数据永远不过期，加互斥锁

1）后台刷新

后台定义一个job(定时任务)专门主动更新缓存数据.比如,一个缓存中的数据过期时间是30分钟,那么job每隔29分钟定时刷新数据(将从数据库中查到的数据更新到缓存中).

注：这种方案比较容易理解，但会增加系统复杂度。比较适合那些 key 相对固定,cache 粒度较大的业务，key 比较分散的则不太适合，实现起来也比较复杂。

2）检查更新

将缓存key的过期时间(绝对时间)一起保存到缓存中(可以拼接,可以添加新字段,可以采用单独的key保存..不管用什么方式,只要两者建立好关联关系就行).在每次执行get操作后,都将get出来的缓存过期时间与当前系统时间做一个对比,如果缓存过期时间-当前系统时间<=1分钟(自定义的一个值),则主动更新缓存.这样就能保证缓存中的数据始终是最新的(和方案一一样,让数据不过期.)

注：这种方案在特殊情况下也会有问题。假设缓存过期时间是12:00，而 11:59 到 12:00这 1 分钟时间里恰好没有 get 请求过来，又恰好请求都在 11:30 分的时 候高并发过来，那就悲剧了。这种情况比较极端，但并不是没有可能。因为“高 并发”也可能是阶段性在某个时间点爆发。

3）分级缓存

采用 L1 (一级缓存)和 L2(二级缓存) 缓存方式，L1 缓存失效时间短，L2 缓存失效时间长。 请求优先从 L1 缓存获取数据，如果 L1缓存未命中则加锁，只有 1 个线程获取到锁,这个线程再从数据库中读取数据并将数据再更新到到 L1 缓存和 L2 缓存中，而其他线程依旧从 L2 缓存获取数据并返回。

注：这种方式，主要是通过避免缓存同时失效并结合锁机制实现。所以，当数据更 新时，只能淘汰 L1 缓存，不能同时将 L1 和 L2 中的缓存同时淘汰。L2 缓存中 可能会存在脏数据，需要业务能够容忍这种短时间的不一致。而且，这种方案 可能会造成额外的缓存空间浪费。

4）加锁：互斥锁 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

static Lock reenLock = new ReentrantLock();        public List<String> getData04() throws InterruptedException {         List<String> result = new ArrayList<String>();         // 从缓存读取数据         result = getDataFromCache();         if (result.isEmpty()) {             if (reenLock.tryLock()) {                 try {                     System.out.println("我拿到锁了,从DB获取数据库后写入缓存");                     // 从数据库查询数据                     result = getDataFromDB();                     // 将查询到的数据写入缓存                     setDataToCache(result);                 } finally {                     reenLock.unlock();// 释放锁                 }                } else {                 result = getDataFromCache();// 先查一下缓存                 if (result.isEmpty()) {                     System.out.println("我没拿到锁,缓存也没数据,先小憩一下");                     Thread.sleep(100);// 小憩一会儿                     return getData04();// 重试                 }             }         }         return result;     }