緩存穿透，緩存擊穿，緩存雪崩解決方案分析

一：前言

設計一個緩存系統，不得不要考慮的問題就是：緩存穿透、緩存擊穿與失效時的雪崩效應。

二：緩存穿透

緩存穿透是指查詢一個必定不存在的數據，因爲緩存是不命中時被動寫的，而且出於容錯考慮，若是從存儲層查不到數據則不寫入緩存，這將致使這個不存在的數據每次請求都要到存儲層去查詢，失去了緩存的意義。在流量大時，可能DB就掛掉了，要是有人利用不存在的key頻繁攻擊咱們的應用，這就是漏洞。

 

三：解決方案

有不少種方法能夠有效地解決緩存穿透問題，最多見的則是採用布隆過濾器，將全部可能存在的數據哈希到一個足夠大的bitmap中，一個必定不存在的數據會被 這個bitmap攔截掉，從而避免了對底層存儲系統的查詢壓力。另外也有一個更爲簡單粗暴的方法（咱們採用的就是這種），若是一個查詢返回的數據爲空（不論是數 據不存在，仍是系統故障），咱們仍然把這個空結果進行緩存，但它的過時時間會很短，最長不超過五分鐘。

 

四：緩存雪崩

緩存雪崩是指在咱們設置緩存時採用了相同的過時時間，致使緩存在某一時刻同時失效，請求所有轉發到DB，DB瞬時壓力太重雪崩。

 

五：解決方案

緩存失效時的雪崩效應對底層系統的衝擊很是可怕。大多數系統設計者考慮用加鎖或者隊列的方式保證緩存的單線 程（進程）寫，從而避免失效時大量的併發請求落到底層存儲系統上。這裏分享一個簡單方案就時講緩存失效時間分散開，好比咱們能夠在原有的失效時間基礎上增長一個隨機值，好比1-5分鐘隨機，這樣每個緩存的過時時間的重複率就會下降，就很難引起集體失效的事件。

六：緩存擊穿

對於一些設置了過時時間的key，若是這些key可能會在某些時間點被超高併發地訪問，是一種很是「熱點」的數據。這個時候，須要考慮一個問題：緩存被「擊穿」的問題，這個和緩存雪崩的區別在於這裏針對某一key緩存，前者則是不少key。

 

緩存在某個時間點過時的時候，剛好在這個時間點對這個Key有大量的併發請求過來，這些請求發現緩存過時通常都會從後端DB加載數據並回設到緩存，這個時候大併發的請求可能會瞬間把後端DB壓垮。

 

七：解決方案

一、使用互斥鎖(mutex key)

業界比較經常使用的作法，是使用mutex。簡單地來講，就是在緩存失效的時候（判斷拿出來的值爲空），不是當即去load db，而是先使用緩存工具的某些帶成功操做返回值的操做（好比Redis的SETNX或者Memcache的ADD）去set一個mutex key，當操做返回成功時，再進行load db的操做並回設緩存；不然，就重試整個get緩存的方法。

 

SETNX，是「SET if Not eXists」的縮寫，也就是隻有不存在的時候才設置，能夠利用它來實現鎖的效果。在redis2.6.1以前版本未實現setnx的過時時間，因此這裏給出兩種版本代碼參考：

 1 //2.6.1前單機版本鎖
 2 String get(String key) {  
 3    String value = redis.get(key);  
 4    if (value  == null) {  
 5     if (redis.setnx(key_mutex, "1")) {  
 6         // 3 min timeout to avoid mutex holder crash  
 7         redis.expire(key_mutex, 3 * 60)  
 8         value = db.get(key);  
 9         redis.set(key, value);  
10         redis.delete(key_mutex);  
11     } else {  
12         //其餘線程休息50毫秒後重試  
13         Thread.sleep(50);  
14         get(key);  
15     }  
16   }  
17 }

 

 

最新版本代碼：

 1 public String get(key) {
 2       String value = redis.get(key);
 3       if (value == null) { //表明緩存值過時
 4           //設置3min的超時，防止del操做失敗的時候，下次緩存過時一直不能load db
 5           if (redis.setnx(key_mutex, 1, 3 * 60) == 1) {  //表明設置成功
 6                value = db.get(key);
 7                       redis.set(key, value, expire_secs);
 8                       redis.del(key_mutex);
 9               } else {  //這個時候表明同時候的其餘線程已經load db並回設到緩存了，這時候重試獲取緩存值便可
10                       sleep(50);
11                       get(key);  //重試
12               }
13           } else {
14               return value;      
15           }
16  }

 

 

memcache代碼

 1 if (memcache.get(key) == null) {  
 2     // 3 min timeout to avoid mutex holder crash  
 3     if (memcache.add(key_mutex, 3 * 60 * 1000) == true) {  
 4         value = db.get(key);  
 5         memcache.set(key, value);  
 6         memcache.delete(key_mutex);  
 7     } else {  
 8         sleep(50);  
 9         retry();  
10     }  
11 } 

 

 

二、"提早"使用互斥鎖(mutex key)：

在value內部設置1個超時值(timeout1), timeout1比實際的memcache timeout(timeout2)小。當從cache讀取到timeout1發現它已通過期時候，立刻延長timeout1並從新設置到cache。而後再從數據庫加載數據並設置到cache中。僞代碼以下：

 1 v = memcache.get(key);  
 2 if (v == null) {  
 3     if (memcache.add(key_mutex, 3 * 60 * 1000) == true) {  
 4         value = db.get(key);  
 5         memcache.set(key, value);  
 6         memcache.delete(key_mutex);  
 7     } else {  
 8         sleep(50);  
 9         retry();  
10     }  
11 } else {  
12     if (v.timeout <= now()) {  
13         if (memcache.add(key_mutex, 3 * 60 * 1000) == true) {  
14             // extend the timeout for other threads  
15             v.timeout += 3 * 60 * 1000;  
16             memcache.set(key, v, KEY_TIMEOUT * 2);  
17 
18             // load the latest value from db  
19             v = db.get(key);  
20             v.timeout = KEY_TIMEOUT;  
21             memcache.set(key, value, KEY_TIMEOUT * 2);  
22             memcache.delete(key_mutex);  
23         } else {  
24             sleep(50);  
25             retry();  
26         }  
27     }  
28 } 

 

 

三、"永遠不過時"：

這裏的「永遠不過時」包含兩層意思：

(1) 從redis上看，確實沒有設置過時時間，這就保證了，不會出現熱點key過時問題，也就是「物理」不過時。
(2) 從功能上看，若是不過時，那不就成靜態的了嗎？因此咱們把過時時間存在key對應的value裏，若是發現要過時了，經過一個後臺的異步線程進行緩存的構建，也就是「邏輯」過時

 

從實戰看，這種方法對於性能很是友好，惟一不足的就是構建緩存時候，其他線程(非構建緩存的線程)可能訪問的是老數據，可是對於通常的互聯網功能來講這個仍是能夠忍受。

 1 String get(final String key) {  
 2         V v = redis.get(key);  
 3         String value = v.getValue();  
 4         long timeout = v.getTimeout();  
 5         if (v.timeout <= System.currentTimeMillis()) {  
 6             // 異步更新後臺異常執行  
 7             threadPool.execute(new Runnable() {  
 8                 public void run() {  
 9                     String keyMutex = "mutex:" + key;  
10                     if (redis.setnx(keyMutex, "1")) {  
11                         // 3 min timeout to avoid mutex holder crash  
12                         redis.expire(keyMutex, 3 * 60);  
13                         String dbValue = db.get(key);  
14                         redis.set(key, dbValue);  
15                         redis.delete(keyMutex);  
16                     }  
17                 }  
18             });  
19         }  
20         return value;  
21 }

 

四、資源保護：

採用netflix的hystrix，能夠作資源的隔離保護主線程池，若是把這個應用到緩存的構建也何嘗不可。

四種解決方案：沒有最佳只有最合適

 

​

八：總結

針對業務系統，永遠都是具體狀況具體分析，沒有最好，只有最合適。最後，對於緩存系統常見的緩存滿了和數據丟失問題，須要根據具體業務分析，一般咱們採用LRU策略處理溢出，Redis的RDB和AOF持久化策略來保證必定狀況下的數據安全。