今年雙 11 全民購物狂歡節(jié)進(jìn)入第十一個年頭，1 分 36 秒，交易額沖到 100 億 !比 2018 年快了近 30 秒，比 2017 年快了近 1 分半!這個速度再次刷新天貓雙 11 成交總額破 100 億的紀(jì)錄。

圖片來自 Pexels

那么如何抗住雙 11 高并發(fā)流量?接下來讓我們一起來聊聊高可用的“大殺器”限流降級技術(shù)。

服務(wù)等級協(xié)議

我們常說的 N 個 9，就是對 SLA 的一個描述。SLA 全稱是 Service Level Agreement，翻譯為服務(wù)水平協(xié)議，也稱服務(wù)等級協(xié)議，它表明了公有云提供服務(wù)的等級以及質(zhì)量。

例如阿里云對外承諾的就是一個服務(wù)周期內(nèi)集群服務(wù)可用性不低于 99.99%，如果低于這個標(biāo)準(zhǔn)，云服務(wù)公司就需要賠償客戶的損失。

做到 4 個 9 夠好了嗎

對互聯(lián)網(wǎng)公司來說，SLA 就是網(wǎng)站或者 API 服務(wù)可用性的一個保證。

9 越多代表全年服務(wù)可用時間越長服務(wù)更可靠，4 個 9 的服務(wù)可用性，聽起來已經(jīng)很高了，但對于實(shí)際的業(yè)務(wù)場景，這個值可能并不夠。

我們來做一個簡單的計(jì)算，假設(shè)一個核心鏈路依賴 20 個服務(wù)，強(qiáng)依賴同時沒有配置任何降級，并且這 20 個服務(wù)的可用性達(dá)到 4 個 9，也就是 99.99%。

那這個核心鏈路的可用性只有 99.99 的 20 次方=99.8%，如果有 10 億次請求則有 3,000,000 次的失敗請求，理想狀況下，每年還是有 17 小時服務(wù)不可用。

這是一個理想的估算，在實(shí)際的生產(chǎn)環(huán)境中，由于服務(wù)發(fā)布，宕機(jī)等各種各樣的原因，情況肯定會比這個更差。

對于一些比較敏感的業(yè)務(wù)，比如金融，或是對服務(wù)穩(wěn)定要求較高的行業(yè)，比如訂單或者支付業(yè)務(wù)，這樣的情況是不能接受的。

微服務(wù)的雪崩效應(yīng)

除了對服務(wù)可用性的追求，微服務(wù)架構(gòu)一個繞不過去的問題就是服務(wù)雪崩。

在一個調(diào)用鏈路上，微服務(wù)架構(gòu)各個服務(wù)之間組成了一個松散的整體，牽一發(fā)而動全身，服務(wù)雪崩是一個多級傳導(dǎo)的過程。

首先是某個服務(wù)提供者不可用，由于大量超時等待，繼而導(dǎo)致服務(wù)調(diào)用者不可用，并且在整個鏈路上傳導(dǎo)，繼而導(dǎo)致系統(tǒng)癱瘓。

限流降級怎么做

如同上面我們分析的，在大規(guī)模微服務(wù)架構(gòu)的場景下，避免服務(wù)出現(xiàn)雪崩，要減少停機(jī)時間，要盡可能的提高服務(wù)可用性。

提高服務(wù)可用性，可以從很多方向入手，比如緩存、池化、異步化、負(fù)載均衡、隊(duì)列和降級熔斷等手段。

緩存以及隊(duì)列等手段，增加系統(tǒng)的容量。限流和降級則是關(guān)心在到達(dá)系統(tǒng)瓶頸時系統(tǒng)的響應(yīng)，更看重穩(wěn)定性。

緩存和異步等提高系統(tǒng)的戰(zhàn)力，限流降級關(guān)注的是防御。限流和降級，具體實(shí)施方法可以歸納為八字箴言，分別是限流，降級，熔斷和隔離。

限流和降級

限流顧名思義，提前對各個類型的請求設(shè)置最高的 QPS 閾值，若高于設(shè)置的閾值則對該請求直接返回，不再調(diào)用后續(xù)資源。

限流需要結(jié)合壓測等，了解系統(tǒng)的最高水位，也是在實(shí)際開發(fā)中應(yīng)用最多的一種穩(wěn)定性保障手段。

降級則是當(dāng)服務(wù)器壓力劇增的情況下，根據(jù)當(dāng)前業(yè)務(wù)情況及流量對一些服務(wù)和頁面有策略的降級，以此釋放服務(wù)器資源以保證核心任務(wù)的正常運(yùn)行。

從降級配置方式上，降級一般可以分為主動降級和自動降級。主動降級是提前配置，自動降級則是系統(tǒng)發(fā)生故障時，如超時或者頻繁失敗，自動降級。

其中，自動降級，又可以分為以下策略：

• 超時降級
• 失敗次數(shù)降級
• 故障降級

在系統(tǒng)設(shè)計(jì)中，降級一般是結(jié)合系統(tǒng)配置中心，通過配置中心進(jìn)行推送，下面是一個典型的降級通知設(shè)計(jì)。

熔斷隔離

如果某個目標(biāo)服務(wù)調(diào)用慢或者有大量超時，此時熔斷該服務(wù)的調(diào)用，對于后續(xù)調(diào)用請求，不在繼續(xù)調(diào)用目標(biāo)服務(wù)，直接返回，快速釋放資源。

熔斷一般需要設(shè)置不同的恢復(fù)策略，如果目標(biāo)服務(wù)情況好轉(zhuǎn)則恢復(fù)調(diào)用。

服務(wù)隔離與前面的三個略有區(qū)別，我們的系統(tǒng)通常提供了不止一個服務(wù)，但是這些服務(wù)在運(yùn)行時是部署在一個實(shí)例，或者一臺物理機(jī)上面的。

如果不對服務(wù)資源做隔離，一旦一個服務(wù)出現(xiàn)了問題，整個系統(tǒng)的穩(wěn)定性都會受到影響!服務(wù)隔離的目的就是避免服務(wù)之間相互影響。

一般來說，隔離要關(guān)注兩方面，一個是在哪里進(jìn)行隔離，另外一個是隔離哪些資源。

何處隔離：一次服務(wù)調(diào)用，涉及到的是服務(wù)提供方和調(diào)用方，我們所指的資源，也是兩方的服務(wù)器等資源，服務(wù)隔離通?？梢詮奶峁┓胶驼{(diào)用方兩個方面入手。

隔離什么：廣義的服務(wù)隔離，不僅包括服務(wù)器資源，還包括數(shù)據(jù)庫分庫，緩存，索引等，這里我們只關(guān)注服務(wù)層面的隔離。

降級和熔斷的區(qū)別

服務(wù)降級和熔斷在概念上比較相近，通過兩個場景，談?wù)勎易约旱睦斫狻?/p>

熔斷，一般是停止服務(wù)：典型的就是股市的熔斷，如果大盤不受控制，直接休市，不提供服務(wù)，是保護(hù)大盤的一種方式。

降級，通常是有備用方案：從北京到濟(jì)南，下雨導(dǎo)致航班延誤，我可以乘坐高鐵，如果高鐵票買不到，也可以乘坐汽車或者開車過去。

兩者的區(qū)別：降級一般是主動的，有預(yù)見性的，熔斷通常是被動的，服務(wù) A 降級以后，一般會有服務(wù) B 來代替，而熔斷通常是針對核心鏈路的處理。

在實(shí)際開發(fā)中，熔斷的下一步通常就是降級。

常用限流算法設(shè)計(jì)

剛才講了限流的概念，那么怎樣判斷系統(tǒng)到達(dá)設(shè)置的流量閾值了?這就需要一些限流策略來支持，不同的限流算法有不同的特點(diǎn)，平滑程度也不同。

計(jì)數(shù)器法

計(jì)數(shù)器法是限流算法里最簡單也是最容易實(shí)現(xiàn)的一種算法。

假設(shè)一個接口限制一分鐘內(nèi)的訪問次數(shù)不能超過 100 個，維護(hù)一個計(jì)數(shù)器，每次有新的請求過來，計(jì)數(shù)器加一。

這時候判斷，如果計(jì)數(shù)器的值小于限流值，并且與上一次請求的時間間隔還在一分鐘內(nèi)，允許請求通過，否則拒絕請求，如果超出了時間間隔，要將計(jì)數(shù)器清零。

1. public class CounterLimiter { 
2.  
3.     //初始時間 
4.     private static long startTime = System.currentTimeMillis(); 
5.  
6.     //初始計(jì)數(shù)值 
7.     private static final AtomicInteger ZERO = new AtomicInteger(0); 
8.  
9.     //時間窗口限制 
10.     private static final long interval = 10000; 
11.  
12.     //限制通過請求 
13.     private static int limit = 100; 
14.  
15.     //請求計(jì)數(shù) 
16.     private AtomicInteger requestCount = ZERO; 
17.  
18.     //獲取限流 
19.     public boolean tryAcquire() { 
20.  
21.         long now = System.currentTimeMillis(); 
22.  
23.         //在時間窗口內(nèi) 
24.         if (now < startTime + interval) { 
25.  
26.             //判斷是否超過最大請求 
27.             if (requestCount.get() < limit) { 
28.                 requestCount.incrementAndGet(); 
29.                 return true; 
30.             } 
31.             return false; 
32.  
33.         } else { 
34.  
35.             //超時重置 
36.             startTime = now; 
37.             requestCount = ZERO; 
38.             return true; 
39.         } 
40.  
41.     } 
42. } 

計(jì)數(shù)器限流可以比較容易的應(yīng)用在分布式環(huán)境中，用一個單點(diǎn)的存儲來保存計(jì)數(shù)值，比如用 Redis，并且設(shè)置自動過期時間，這時候就可以統(tǒng)計(jì)整個集群的流量，并且進(jìn)行限流。

計(jì)數(shù)器方式的缺點(diǎn)是不能處理臨界問題，或者說限流策略不夠平滑。

假設(shè)在限流臨界點(diǎn)的前后，分別發(fā)送 100 個請求，實(shí)際上在計(jì)數(shù)器置 0 前后的極短時間里，處理了 200 個請求，這是一個瞬時的高峰，可能會超過系統(tǒng)的限制。

計(jì)數(shù)器限流允許出現(xiàn) 2*permitsPerSecond 的突發(fā)流量，可以使用滑動窗口算法去優(yōu)化，具體不展開。

漏桶算法

假設(shè)我們有一個固定容量的桶，桶底部可以漏水(忽略氣壓等，不是物理問題)，并且這個漏水的速率可控的，那么我們可以通過這個桶來控制請求速度，也就是漏水的速度。

我們不關(guān)心流進(jìn)來的水，也就是外部請求有多少，桶滿了之后，多余的水會溢出。

漏桶算法的示意圖如下：

將算法中的水換成實(shí)際應(yīng)用中的請求，可以看到漏桶算法從入口限制了請求的速度。

使用漏桶算法，我們可以保證接口會以一個常速速率來處理請求，所以漏桶算法不會出現(xiàn)臨界問題。

這里簡單實(shí)現(xiàn)一下，也可以使用 Guava 的 SmoothWarmingUp 類，可以更好的控制漏桶算法：

1. public class LeakyLimiter { 
2.  
3.     //桶的容量 
4.     private int capacity; 
5.  
6.     //漏水速度 
7.     private int ratePerMillSecond; 
8.  
9.     //水量 
10.     private double water; 
11.  
12.     //上次漏水時間 
13.     private long lastLeakTime; 
14.  
15.     public LeakyLimiter(int capacity, int ratePerMillSecond) { 
16.  
17.         this.capacity = capacity; 
18.         this.ratePerMillSecond = ratePerMillSecond; 
19.         this.water = 0; 
20.     } 
21.  
22.  
23.     //獲取限流 
24.     public boolean tryAcquire() { 
25.  
26.         //執(zhí)行漏水，更新剩余水量 
27.         refresh(); 
28.  
29.         //嘗試加水，水滿則拒絕 
30.         if (water + 1 > capacity) { 
31.             return false; 
32.         } 
33.  
34.         water = water + 1; 
35.         return true; 
36.  
37.     } 
38.  
39.     private void refresh() { 
40.         //當(dāng)前時間 
41.         long currentTime = System.currentTimeMillis(); 
42.  
43.         if (currentTime > lastLeakTime) { 
44.  
45.             //距上次漏水的時間間隔 
46.             long millisSinceLastLeak = currentTime - lastLeakTime; 
47.             long leaks = millisSinceLastLeak * ratePerMillSecond; 
48.  
49.             //允許漏水 
50.             if (leaks > 0) { 
51.                 //已經(jīng)漏光 
52.                 if (water <= leaks) { 
53.                     water = 0; 
54.                 } else { 
55.                     water = water - leaks; 
56.                 } 
57.                 this.lastLeakTime = currentTime; 
58.             } 
59.         } 
60.     } 
61. } 

令牌桶算法

漏桶是控制水流入的速度，令牌桶則是控制留出，通過控制 Token，調(diào)節(jié)流量。

假設(shè)一個大小恒定的桶，桶里存放著令牌(Token)。桶一開始是空的，現(xiàn)在以一個固定的速率往桶里填充，直到達(dá)到桶的容量，多余的令牌將會被丟棄。

如果令牌不被消耗，或者被消耗的速度小于產(chǎn)生的速度，令牌就會不斷地增多，直到把桶填滿。后面再產(chǎn)生的令牌就會從桶中溢出。

最后桶中可以保存的最大令牌數(shù)永遠(yuǎn)不會超過桶的大小，每當(dāng)一個請求過來時，就會嘗試從桶里移除一個令牌，如果沒有令牌的話，請求無法通過。

1. public class TokenBucketLimiter { 
2.  
3.     private long capacity; 
4.     private long windowTimeInSeconds; 
5.     long lastRefillTimeStamp; 
6.     long refillCountPerSecond; 
7.     long availableTokens; 
8.  
9.     public TokenBucketLimiter(long capacity, long windowTimeInSeconds) { 
10.         this.capacity = capacity; 
11.         this.windowTimeInSeconds = windowTimeInSeconds; 
12.         lastRefillTimeStamp = System.currentTimeMillis(); 
13.         refillCountPerSecond = capacity / windowTimeInSeconds; 
14.         availableTokens = 0; 
15.     } 
16.  
17.     public long getAvailableTokens() { 
18.         return this.availableTokens; 
19.     } 
20.  
21.     public boolean tryAcquire() { 
22.  
23.         //更新令牌桶 
24.         refill(); 
25.  
26.         if (availableTokens > 0) { 
27.             --availableTokens; 
28.             return true; 
29.         } else { 
30.             return false; 
31.         } 
32.     } 
33.  
34.  
35.     private void refill() { 
36.         long now = System.currentTimeMillis(); 
37.  
38.         if (now > lastRefillTimeStamp) { 
39.  
40.             long elapsedTime = now - lastRefillTimeStamp; 
41.  
42.             int tokensToBeAdded = (int) ((elapsedTime / 1000) * refillCountPerSecond); 
43.  
44.             if (tokensToBeAdded > 0) { 
45.                 availableTokens = Math.min(capacity, availableTokens + tokensToBeAdded); 
46.                 lastRefillTimeStamp = now; 
47.             } 
48.         } 
49.     } 
50.  
51. } 

這兩種算法的主要區(qū)別在于漏桶算法能夠強(qiáng)行限制數(shù)據(jù)的傳輸速率，而令牌桶算法在能夠限制數(shù)據(jù)的平均傳輸速率外，還允許某種程度的突發(fā)傳輸。

在令牌桶算法中，只要令牌桶中存在令牌，那么就允許突發(fā)地傳輸數(shù)據(jù)直到達(dá)到用戶配置的門限，因此它適合于具有突發(fā)特性的流量。

漏桶和令牌桶的比較

漏桶和令牌桶算法實(shí)現(xiàn)可以一樣，但是方向是相反的，對于相同的參數(shù)得到的限流效果是一樣的。

主要區(qū)別在于令牌桶允許一定程度的突發(fā)，漏桶主要目的是平滑流入速率，考慮一個臨界場景，令牌桶內(nèi)積累了 100 個 Token，可以在一瞬間通過。

但是因?yàn)橄乱幻氘a(chǎn)生 Token 的速度是固定的，所以令牌桶允許出現(xiàn)瞬間出現(xiàn) permitsPerSecond 的流量，但是不會出現(xiàn) 2*permitsPerSecond 的流量，漏桶的速度則始終是平滑的。

使用 RateLimiter 實(shí)現(xiàn)限流

Google 開源工具包 Guava 提供了限流工具類 RateLimiter，該類基于令牌桶算法實(shí)現(xiàn)流量限制，使用方便。

RateLimiter 使用的是令牌桶的流控算法，RateLimiter 會按照一定的頻率往桶里扔令牌，線程拿到令牌才能執(zhí)行。

比如你希望自己的應(yīng)用程序 QPS 不要超過 1000，那么 RateLimiter 設(shè)置 1000 的速率后，就會每秒往桶里扔 1000 個令牌，看下方法的說明：

RateLimter 提供的 API 可以直接應(yīng)用，其中 acquire 會阻塞，類似 JUC 的信號量 Semphore，tryAcquire 方法則是非阻塞的：

1. public class RateLimiterTest { 
2.  
3.     public static void main(String[] args) throws InterruptedException { 
4.  
5.         //允許10個，permitsPerSecond 
6.         RateLimiter limiter = RateLimiter.create(10); 
7.  
8.         for(int i=1;i<20;i++){ 
9.             if (limiter.tryAcquire(1)){ 
10.                 System.out.println("第"+i+"次請求成功"); 
11.             }else{ 
12.                 System.out.println("第"+i+"次請求拒絕"); 
13.             } 
14.         } 
15.     } 
16. } 

總結(jié)

本文從服務(wù)可用性開始，分析了在業(yè)務(wù)高峰期通過限流降級保障服務(wù)高可用的重要性。

接下來分別探討了限流，降級，熔斷，隔離的概念和應(yīng)用，并且介紹了常用的限流策略。

作者：邴越

簡介：某電商平臺架構(gòu)師，曾任阿里巴巴中臺資深開發(fā)工程師，云棲社區(qū)專家，關(guān)注分布式系統(tǒng)和高可用架構(gòu)。