明白了缓存穿透和缓存雪崩，再了解一下缓存击穿！

缓存击穿和缓存雪崩的区别在于：雪崩针对不少 key，而击穿只针对于某一个热点 key。

设置缓存永不过时，这个方法虽然很暴力，可是确实能解决大部分的问题，固然，大部分场景也不太适用；

设置随机过时时间，这个方案对于缓存击穿来讲就不太适用了，由于击穿只针对一个热点 key，只要它一失效，大量的访问就会击垮数据库；

其他的方案好比使用互斥锁、双缓存机制，也均可以解决缓存击穿的问题，让咱们看看这些方案的具体实现。

主动刷新缓存

缓存设置成永不过时，在更新或删除 DB 中的数据时，也主动地把缓存中的数据更新或删除掉。

这个方案很容易理解，可是实现起来却很复杂，但凡须要使用缓存的数据，都须要增长双写数据库和缓存的代码，而且双写过程当中，还须要保持数据一致性。

检查更新

缓存依然保持设置过时时间，每次 get 缓存的时候，都和数据的过时时间和当前时间进行一下对比，当间隔时间小于一个阈值的时候，主动更新缓存。

好比（缓存过时时间 - 当前系统时间）小于 5 分钟，那么就刷新一次缓存，而且重置缓存过时时间；

不过这个方法也有个致命的问题：若是一个数据，刚好在缓存失效前五分钟，一次访问都没有，那么就不会触发检查更新，当缓存失效后有大量请求访问，那么也会形成缓存击穿。

使用锁

在缓存失效后，经过互斥锁或者队列，控制读数据库和写缓存的线程数量。

第一种方法：整个方法是 synchronized 的，这样作虽然能够防止大量请求落到 DB 上，可是就算是缓存没有失效，须要从 DB 中查询数据也须要排队，无疑是下降了系统的吞吐量。

public synchronized String getCacheData() {
      String cacheData = "";
      //读 Redis
      cacheData = getDataFromRedis();
      if (cacheData.isEmpty()) {
          //读数据库
          cacheData = getDataFromDB();
          //写 Redis
          setDataToCache(cacheData);
      }
      return cacheData;
}
复制代码

第二种方法：当缓存失效时，只对查询数据库的操做进行加锁，这样对于缓存没有失效的状况也很是友好，可是查询操做这里加锁，也只是会阻塞掉住其余调用，第一其余线程要等待，对调用方不友好，第二这些请求被阻塞的请求最终仍是会落到 DB 上的。

static Object lock = new Object();

public String getCacheData() {
      String cacheData = "";
      // 读 Redis
      cacheData = getDataFromRedis();
      if (cacheData.isEmpty()) {
          synchronized (lock) {
              //读数据库
           cacheData = getDataFromDB();
              //写 Redis
              setDataToCache(cacheData);
          }
      }
      return cacheData;
 }
复制代码

第三种方法：使用互斥锁，抢到锁的话读数据库并写入缓存，抢不到锁的话也不阻塞，而是直接去读缓存，若是缓存中依然读不到数据（抢到锁的可能尚未将缓存写入成功），就等一会再试试读缓存。

public String getCacheData(){
   String result = "";
      //读 Redis
      result = getDataFromRedis();
      if (result.isEmpty()) {
          if (reenLock.tryLock()) {
              try {
                  //读数据库
                  result = getDataFromDB();
                  //写 Redis
                  setDataToCache(result);
              }catch(Exception e){
               //...
              }finally {
                  reenLock.unlock();//释放锁
              }
          } else {
                //注意：这里能够结合下文中的双缓存机制：
                //抢不到锁的去查询二级缓存
              //读 Redis
              result = getDataFromRedis();
              if (result.isEmpty()) {
                  try {
                    Thread.sleep(100);
                  } catch (InterruptedException e) {
                  //...
              }
                  return getCacheData();
              }
          }
      }
      return result;
}
复制代码

双缓存

设置一级缓存和二级缓存，一级缓存过时时间短，二级缓存过时时间长或者不过时，一级缓存失效后访问二级缓存，同时刷新一级缓存和二级缓存。

双缓存的方式，说白了就是不能将一级缓存和二级缓存中数据同时变成失效，当一级缓存失效后，有多个请求访问，彼此之间依然是竞争锁，抢到锁的线程查询数据库并刷新缓存，而其余没有抢到锁的线程，直接访问二级缓存（代码能够参考上文中的互斥锁），如图：

双缓存机制

会点代码的大叔 | 文【原创】

---

@会点代码的大叔