開發高并發系統的三把利器

在開發高并發系統時有三把利器用來保護系統：緩存、降級和限流。緩存的目的是提升系統通路速度和增大系統能處理的容量，可謂是抗高并發流量的銀彈；而降級是當服務出問題或者影響到核心流程的性能則需要暫時屏蔽掉，待高峰或者問題解決後再打開；而有些場景并不能用緩存和降級來解決，比如稀缺資源（秒殺、搶購）、寫服務（如評論、下單）、頻繁的複雜查詢（評論的最後幾頁），是以需有一種手段來限制這些場景的并發/請求量，即限流。

限流的目的是通過對并發通路/請求進行限速或者一個時間視窗内的的請求進行限速來保護系統，一旦達到限制速率則可以拒絕服務（定向到錯誤頁或告知資源沒有了）、排隊或等待（比如秒殺、評論、下單）、降級（傳回兜底資料或預設資料，如商品詳情頁庫存預設有貨）。

一般開發高并發系統常見的限流有：限制總并發數（比如資料庫連接配接池、線程池）、限制瞬時并發數（如nginx的limit_conn子產品，用來限制瞬時并發連接配接數）、限制時間視窗内的平均速率（如Guava的RateLimiter、nginx的limit_req子產品，限制每秒的平均速率）；其他還有如限制遠端接口調用速率、限制MQ的消費速率。另外還可以根據網絡連接配接數、網絡流量、CPU或記憶體負載等來限流。

先有緩存這個銀彈，後有限流來應對618、雙十一高并發流量，在處理高并發問題上可以說是如虎添翼，不用擔心瞬間流量導緻系統挂掉或雪崩，最終做到有損服務而不是不服務；限流需要評估好，不可亂用，否則會正常流量出現一些奇怪的問題而導緻使用者抱怨。

在實際應用時也不要太糾結算法問題，因為一些限流算法實作是一樣的隻是描述不一樣；具體使用哪種限流技術還是要根據實際場景來選擇，不要一味去找最佳模式，白貓黑貓能解決問題的就是好貓。

因在實際工作中遇到過許多人來問如何進行限流，是以本文會詳細介紹各種限流手段。那麼接下來我們從限流算法、應用級限流、分布式限流、接入層限流來詳細學習下限流技術手段。

限流算法

常見的限流算法有：令牌桶、漏桶。計數器也可以進行粗暴限流實作。

令牌桶算法

令牌桶算法是一個存放固定容量令牌的桶，按照固定速率往桶裡添加令牌。令牌桶算法的描述如下：

• 假設限制2r/s，則按照500毫秒的固定速率往桶中添加令牌；
• 桶中最多存放b個令牌，當桶滿時，新添加的令牌被丢棄或拒絕；
• 當一個n個位元組大小的資料包到達，将從桶中删除n個令牌，接着資料包被發送到網絡上；
• 如果桶中的令牌不足n個，則不會删除令牌，且該資料包将被限流（要麼丢棄，要麼緩沖區等待）。

漏桶算法

漏桶作為計量工具（The Leaky Bucket Algorithm as a Meter）時，可以用于流量整形（Traffic Shaping）和流量控制（TrafficPolicing），漏桶算法的描述如下：

• 一個固定容量的漏桶，按照常量固定速率流出水滴；
• 如果桶是空的，則不需流出水滴；
• 可以以任意速率流入水滴到漏桶；
• 如果流入水滴超出了桶的容量，則流入的水滴溢出了（被丢棄），而漏桶容量是不變的。

令牌桶和漏桶對比：

• 令牌桶是按照固定速率往桶中添加令牌，請求是否被處理需要看桶中令牌是否足夠，當令牌數減為零時則拒絕新的請求；
• 漏桶則是按照常量固定速率流出請求，流入請求速率任意，當流入的請求數累積到漏桶容量時，則新流入的請求被拒絕；
• 令牌桶限制的是平均流入速率（允許突發請求，隻要有令牌就可以處理，支援一次拿3個令牌，4個令牌），并允許一定程度突發流量；
• 漏桶限制的是常量流出速率（即流出速率是一個固定常量值，比如都是1的速率流出，而不能一次是1，下次又是2），進而平滑突發流入速率；
• 令牌桶允許一定程度的突發，而漏桶主要目的是平滑流入速率；
• 兩個算法實作可以一樣，但是方向是相反的，對于相同的參數得到的限流效果是一樣的。

另外有時候我們還使用計數器來進行限流，主要用來限制總并發數，比如資料庫連接配接池、線程池、秒殺的并發數；隻要全局總請求數或者一定時間段的總請求數設定的閥值則進行限流，是簡單粗暴的總數量限流，而不是平均速率限流。

到此基本的算法就介紹完了，接下來我們首先看看應用級限流。

應用級限流

限流總并發/連接配接/請求數

對于一個應用系統來說一定會有極限并發/請求數，即總有一個TPS/QPS閥值，如果超了閥值則系統就會不響應使用者請求或響應的非常慢，是以我們最好進行過載保護，防止大量請求湧入擊垮系統。

如果你使用過Tomcat，其Connector 其中一種配置有如下幾個參數：

acceptCount：如果Tomcat的線程都忙于響應，新來的連接配接會進入隊列排隊，如果超出排隊大小，則拒絕連接配接；

maxConnections： 瞬時最大連接配接數，超出的會排隊等待；

maxThreads：Tomcat能啟動用來處理請求的最大線程數，如果請求處理量一直遠遠大于最大線程數則可能會僵死。

詳細的配置請參考官方文檔。另外如Mysql（如max_connections）、Redis（如tcp-backlog）都會有類似的限制連接配接數的配置。

限流總資源數

如果有的資源是稀缺資源（如資料庫連接配接、線程），而且可能有多個系統都會去使用它，那麼需要限制應用；可以使用池化技術來限制總資源數：連接配接池、線程池。比如配置設定給每個應用的資料庫連接配接是100，那麼本應用最多可以使用100個資源，超出了可以等待或者抛異常。

限流某個接口的總并發/請求數

如果接口可能會有突發通路情況，但又擔心通路量太大造成崩潰，如搶購業務；這個時候就需要限制這個接口的總并發/請求數總請求數了；因為粒度比較細，可以為每個接口都設定相應的閥值。可以使用Java中的AtomicLong進行限流：

try {
    if(atomic.incrementAndGet() > 限流數) {
        //拒絕請求
   }
    //處理請求
} finally {
    atomic.decrementAndGet();
}      

适合對業務無損的服務或者需要過載保護的服務進行限流，如搶購業務，超出了大小要麼讓使用者排隊，要麼告訴使用者沒貨了，對使用者來說是可以接受的。而一些開放平台也會限制使用者調用某個接口的試用請求量，也可以用這種計數器方式實作。這種方式也是簡單粗暴的限流，沒有平滑處理，需要根據實際情況選擇使用；

限流某個接口的時間窗請求數

即一個時間視窗内的請求數，如想限制某個接口/服務每秒/每分鐘/每天的請求數/調用量。如一些基礎服務會被很多其他系統調用，比如商品詳情頁服務會調用基礎商品服務調用，但是怕因為更新量比較大将基礎服務打挂，這時我們要對每秒/每分鐘的調用量進行限速；一種實作方式如下所示：

LoadingCache<Long, AtomicLong> counter =
        CacheBuilder.newBuilder()
                .expireAfterWrite(2, TimeUnit.SECONDS)
                .build(new CacheLoader<Long, AtomicLong>() {
                    @Override
                    public AtomicLong load(Long seconds) throws Exception {
                        return new AtomicLong(0);
                    }
                });
long limit = 1000;
while(true) {
    //得到目前秒
    long currentSeconds = System.currentTimeMillis() / 1000;
    if(counter.get(currentSeconds).incrementAndGet() > limit) {
        System.out.println("限流了:" + currentSeconds);
        continue;
    }
    //業務處理
}      

 我們使用Guava的Cache來存儲計數器，過期時間設定為2秒（保證1秒内的計數器是有的），然後我們擷取目前時間戳然後取秒數來作為KEY進行計數統計和限流，這種方式也是簡單粗暴，剛才說的場景夠用了。

平滑限流某個接口的請求數

之前的限流方式都不能很好地應對突發請求，即瞬間請求可能都被允許進而導緻一些問題；是以在一些場景中需要對突發請求進行整形，整形為平均速率請求處理（比如5r/s，則每隔200毫秒處理一個請求，平滑了速率）。這個時候有兩種算法滿足我們的場景：令牌桶和漏桶算法。Guava架構提供了令牌桶算法實作，可直接拿來使用。

Guava RateLimiter提供了令牌桶算法實作：平滑突發限流(SmoothBursty)和平滑預熱限流(SmoothWarmingUp)實作。

SmoothBursty

RateLimiter limiter = RateLimiter.create(5);
System.out.println(limiter.acquire());
System.out.println(limiter.acquire());
System.out.println(limiter.acquire());
System.out.println(limiter.acquire());
System.out.println(limiter.acquire());
System.out.println(limiter.acquire());      

   将得到類似如下的輸出：

  0.0

  0.198239

  0.196083

  0.200609

  0.199599

  0.19961

1、RateLimiter.create(5) 表示桶容量為5且每秒新增5個令牌，即每隔200毫秒新增一個令牌；

2、limiter.acquire()表示消費一個令牌，如果目前桶中有足夠令牌則成功（傳回值為0），如果桶中沒有令牌則暫停一段時間，比如發令牌間隔是200毫秒，則等待200毫秒後再去消費令牌（如上測試用例傳回的為0.198239，差不多等待了200毫秒桶中才有令牌可用），這種實作将突發請求速率平均為了固定請求速率。

再看一個突發示例：

RateLimiter limiter = RateLimiter.create(5);

System.out.println(limiter.acquire(5));

System.out.println(limiter.acquire(1));

System.out.println(limiter.acquire(1));

将得到類似如下的輸出：

0.0

0.98745

0.183553

0.199909

limiter.acquire(5)表示桶的容量為5且每秒新增5個令牌，令牌桶算法允許一定程度的突發，是以可以一次性消費5個令牌，但接下來的limiter.acquire(1)将等待差不多1秒桶中才能有令牌，且接下來的請求也整形為固定速率了。

RateLimiter limiter = RateLimiter.create(5);

System.out.println(limiter.acquire(10));

System.out.println(limiter.acquire(1));

System.out.println(limiter.acquire(1));

将得到類似如下的輸出：

0.0

1.997428

0.192273

0.200616

同上邊的例子類似，第一秒突發了10個請求，令牌桶算法也允許了這種突發（允許消費未來的令牌），但接下來的limiter.acquire(1)将等待差不多2秒桶中才能有令牌，且接下來的請求也整形為固定速率了。

接下來再看一個突發的例子：

RateLimiter limiter = RateLimiter.create(2);

System.out.println(limiter.acquire());

Thread.sleep(2000L);

System.out.println(limiter.acquire());

System.out.println(limiter.acquire());

System.out.println(limiter.acquire());

System.out.println(limiter.acquire());

System.out.println(limiter.acquire());

将得到類似如下的輸出：

0.0

0.0

0.0

0.0

0.499876

0.495799

1、建立了一個桶容量為2且每秒新增2個令牌；

2、首先調用limiter.acquire()消費一個令牌，此時令牌桶可以滿足（傳回值為0）；

3、然後線程暫停2秒，接下來的兩個limiter.acquire()都能消費到令牌，第三個limiter.acquire()也同樣消費到了令牌，到第四個時就需要等待500毫秒了。

此處可以看到我們設定的桶容量為2（即允許的突發量），這是因為SmoothBursty中有一個參數：最大突發秒數（maxBurstSeconds）預設值是1s，突發量/桶容量=速率*maxBurstSeconds，是以本示例桶容量/突發量為2，例子中前兩個是消費了之前積攢的突發量，而第三個開始就是正常計算的了。令牌桶算法允許将一段時間内沒有消費的令牌暫存到令牌桶中，留待未來使用，并允許未來請求的這種突發。

SmoothBursty通過平均速率和最後一次新增令牌的時間計算出下次新增令牌的時間的，另外需要一個桶暫存一段時間内沒有使用的令牌（即可以突發的令牌數）。另外RateLimiter還提供了tryAcquire方法來進行無阻塞或可逾時的令牌消費。

因為SmoothBursty允許一定程度的突發，會有人擔心如果允許這種突發，假設突然間來了很大的流量，那麼系統很可能扛不住這種突發。是以需要一種平滑速率的限流工具，進而系統冷啟動後慢慢的趨于平均固定速率（即剛開始速率小一些，然後慢慢趨于我們設定的固定速率）。Guava也提供了SmoothWarmingUp來實作這種需求，其可以認為是漏桶算法，但是在某些特殊場景又不太一樣。

SmoothWarmingUp建立方式：RateLimiter.create(doublepermitsPerSecond, long warmupPeriod, TimeUnit unit)

permitsPerSecond表示每秒新增的令牌數，warmupPeriod表示在從冷啟動速率過渡到平均速率的時間間隔。

示例如下：

RateLimiter limiter = RateLimiter.create(5, 1000, TimeUnit.MILLISECONDS);

for(int i = 1; i < 5;i++) {

    System.out.println(limiter.acquire());

}

Thread.sleep(1000L);

for(int i = 1; i < 5;i++) {

    System.out.println(limiter.acquire());

}

将得到類似如下的輸出：

0.0

0.51767

0.357814

0.219992

0.199984

0.0

0.360826

0.220166

0.199723

0.199555

速率是梯形上升速率的，也就是說冷啟動時會以一個比較大的速率慢慢到平均速率；然後趨于平均速率（梯形下降到平均速率）。可以通過調節warmupPeriod參數實作一開始就是平滑固定速率。

到此應用級限流的一些方法就介紹完了。假設将應用部署到多台機器，應用級限流方式隻是單應用内的請求限流，不能進行全局限流。是以我們需要分布式限流和接入層限流來解決這個問題。

分布式限流

分布式限流最關鍵的是要将限流服務做成原子化，而解決方案可以使使用redis+lua或者nginx+lua技術進行實作，通過這兩種技術可以實作的高并發和高性能。

首先我們來使用redis+lua實作時間窗内某個接口的請求數限流，實作了該功能後可以改造為限流總并發/請求數和限制總資源數。Lua本身就是一種程式設計語言，也可以使用它實作複雜的令牌桶或漏桶算法。

redis+lua實作中的lua腳本：

local key = KEYS[1] --限流KEY（一秒一個）

local limit = tonumber(ARGV[1]) --限流大小

local current = tonumber(redis.call("INCRBY", key, "1")) --請求數+1

if current > limit then --如果超出限流大小

    return 0

elseif current == 1 then --隻有第一次通路需要設定2秒的過期時間

    redis.call("expire", key,"2")

end

return 1

如上操作因是在一個lua腳本中，又因Redis是單線程模型，是以是線程安全的。如上方式有一個缺點就是當達到限流大小後還是會遞增的，可以改造成如下方式實作：

local key = KEYS[1] --限流KEY（一秒一個）

local limit = tonumber(ARGV[1]) --限流大小

local current = tonumber(redis.call('get', key) or "0")

if current + 1 > limit then --如果超出限流大小

    return 0

else --請求數+1，并設定2秒過期

    redis.call("INCRBY", key,"1")

    redis.call("expire", key,"2")

    return 1

end

如下是Java中判斷是否需要限流的代碼：

public static boolean acquire() throws Exception {

String luaScript = Files.toString(new File("limit.lua"), Charset.defaultCharset());

Jedis jedis = new Jedis("192.168.147.52", 6379);

String key = "ip:" + System.currentTimeMillis()/ 1000; //此處将目前時間戳取秒數

Stringlimit = "3"; //限流大小

return (Long)jedis.eval(luaScript,Lists.newArrayList(key), Lists.newArrayList(limit)) == 1;

}

因為Redis的限制（Lua中有寫操作不能使用帶随機性質的讀操作，如TIME）不能在Redis Lua中使用TIME擷取時間戳，是以隻好從應用擷取然後傳入，在某些極端情況下（機器時鐘不準的情況下），限流會存在一些小問題。

使用Nginx+Lua實作的Lua腳本：

local locks = require "resty.lock"

local function acquire()

    local lock =locks:new("locks")

    local elapsed, err =lock:lock("limit_key") --互斥鎖

    local limit_counter =ngx.shared.limit_counter --計數器

    local key = "ip:" ..os.time()

    local limit = 5 --限流大小

    local current =limit_counter:get(key)

    if current ~= nil and current + 1> limit then --如果超出限流大小

        lock:unlock()

        return 0

    end

    if current == nil then

        limit_counter:set(key, 1, 1) --第一次需要設定過期時間，設定key的值為1，過期時間為1秒

    else

        limit_counter:incr(key, 1) --第二次開始加1即可

    end

    lock:unlock()

    return 1

end

ngx.print(acquire())

實作中我們需要使用lua-resty-lock互斥鎖子產品來解決原子性問題(在實際工程中使用時請考慮擷取鎖的逾時問題)，并使用ngx.shared.DICT共享字典來實作計數器。如果需要限流則傳回0，否則傳回1。使用時需要先定義兩個共享字典（分别用來存放鎖和計數器資料）：

Java代碼  

1. http {  
2.     ……  
3.     lua_shared_dict locks 10m;  
4.     lua_shared_dict limit_counter 10m;  
5. }  

有人會糾結如果應用并發量非常大那麼redis或者nginx是不是能抗得住；不過這個問題要從多方面考慮：你的流量是不是真的有這麼大，是不是可以通過一緻性哈希将分布式限流進行分片，是不是可以當并發量太大降級為應用級限流；對策非常多，可以根據實際情況調節；像在京東使用Redis+Lua來限流搶購流量，一般流量是沒有問題的。

對于分布式限流目前遇到的場景是業務上的限流，而不是流量入口的限流；流量入口限流應該在接入層完成，而接入層筆者一般使用Nginx。

接入層限流

接入層通常指請求流量的入口，該層的主要目的有：負載均衡、非法請求過濾、請求聚合、緩存、降級、限流、A/B測試、服務品質監控等等，可以參考筆者寫的《使用Nginx+Lua(OpenResty)開發高性能Web應用》。

對于Nginx接入層限流可以使用Nginx自帶了兩個子產品：連接配接數限流子產品ngx_http_limit_conn_module和漏桶算法實作的請求限流子產品ngx_http_limit_req_module。還可以使用OpenResty提供的Lua限流子產品lua-resty-limit-traffic進行更複雜的限流場景。

limit_conn用來對某個KEY對應的總的網絡連接配接數進行限流，可以按照如IP、域名次元進行限流。limit_req用來對某個KEY對應的請求的平均速率進行限流，并有兩種用法：平滑模式（delay）和允許突發模式(nodelay)。

ngx_http_limit_conn_module

limit_conn是對某個KEY對應的總的網絡連接配接數進行限流。可以按照IP來限制IP次元的總連接配接數，或者按照服務域名來限制某個域名的總連接配接數。但是記住不是每一個請求連接配接都會被計數器統計，隻有那些被Nginx處理的且已經讀取了整個請求頭的請求連接配接才會被計數器統計。

配置示例：

http {

    limit_conn_zone$binary_remote_addr zone=addr:10m; 

    limit_conn_log_level error; 

    limit_conn_status 503;

    ...

    server {

    ...

    location /limit {

        limit_conn addr 1;

    }

limit_conn：要配置存放KEY和計數器的共享記憶體區域和指定KEY的最大連接配接數；此處指定的最大連接配接數是1，表示Nginx最多同時并發處理1個連接配接；

limit_conn_zone：用來配置限流KEY、及存放KEY對應資訊的共享記憶體區域大小；此處的KEY是“$binary_remote_addr”其表示IP位址，也可以使用如$server_name作為KEY來限制域名級别的最大連接配接數；

limit_conn_status：配置被限流後傳回的狀态碼，預設傳回503；

limit_conn_log_level：配置記錄被限流後的日志級别，預設error級别。

limit_conn的主要執行過程如下所示：

1、請求進入後首先判斷目前limit_conn_zone中相應KEY的連接配接數是否超出了配置的最大連接配接數；

2.1、如果超過了配置的最大大小，則被限流，傳回limit_conn_status定義的錯誤狀态碼；

2.2、否則相應KEY的連接配接數加1，并注冊請求處理完成的回調函數；

3、進行請求處理；

4、在結束請求階段會調用注冊的回調函數對相應KEY的連接配接數減1。

limt_conn可以限流某個KEY的總并發/請求數，KEY可以根據需要變化。

按照IP限制并發連接配接數配置示例：

首先定義IP次元的限流區域：

limit_conn_zone $binary_remote_addrzone=perip:10m;

接着在要限流的location中添加限流邏輯：

location /limit {

    limit_conn perip 2;

    echo "123";

}

即允許每個IP最大并發連接配接數為2。

使用AB測試工具進行測試，并發數為5個，總的請求數為5個：

ab -n 5 -c 5 http://localhost/limit

将得到如下access.log輸出：

[08/Jun/2016:20:10:51+0800] [1465373451.802] 200

[08/Jun/2016:20:10:51+0800] [1465373451.803] 200

[08/Jun/2016:20:10:51 +0800][1465373451.803] 503

[08/Jun/2016:20:10:51 +0800][1465373451.803] 503

[08/Jun/2016:20:10:51 +0800][1465373451.803] 503

此處我們把access log格式設定為log_format main  '[$time_local] [$msec] $status'；分别是“日期 日期秒/毫秒值 響應狀态碼”。

如果被限流了，則在error.log中會看到類似如下的内容：

2016/06/08 20:10:51 [error] 5662#0: *5limiting connections by zone "perip", client: 127.0.0.1, server: _,request: "GET /limit HTTP/1.0", host: "localhost"

按照域名限制并發連接配接數配置示例：

首先定義域名次元的限流區域：

limit_conn_zone $ server_name zone=perserver:10m;

接着在要限流的location中添加限流邏輯：

location /limit {

    limit_conn perserver 2;

    echo "123";

}

即允許每個域名最大并發請求連接配接數為2；這樣配置可以實作伺服器最大連接配接數限制。

ngx_http_limit_req_module

limit_req是漏桶算法實作，用于對指定KEY對應的請求進行限流，比如按照IP次元限制請求速率。

配置示例：

http {

    limit_req_zone $binary_remote_addr zone=one:10m rate=1r/s;

    limit_conn_log_level error;

    limit_conn_status 503;

    ...

    server {

    ...

    location /limit {

        limit_req zone=one burst=5 nodelay;

    }

limit_req：配置限流區域、桶容量（突發容量，預設0）、是否延遲模式（預設延遲）；

limit_req_zone：配置限流KEY、及存放KEY對應資訊的共享記憶體區域大小、固定請求速率；此處指定的KEY是“$binary_remote_addr”表示IP位址；固定請求速率使用rate參數配置，支援10r/s和60r/m，即每秒10個請求和每分鐘60個請求，不過最終都會轉換為每秒的固定請求速率（10r/s為每100毫秒處理一個請求；60r/m，即每1000毫秒處理一個請求）。

limit_conn_status：配置被限流後傳回的狀态碼，預設傳回503；

limit_conn_log_level：配置記錄被限流後的日志級别，預設error級别。

limit_req的主要執行過程如下所示：

1、請求進入後首先判斷最後一次請求時間相對于目前時間（第一次是0）是否需要限流，如果需要限流則執行步驟2，否則執行步驟3；

2.1、如果沒有配置桶容量（burst），則桶容量為0；按照固定速率處理請求；如果請求被限流，則直接傳回相應的錯誤碼（預設503）；

2.2、如果配置了桶容量（burst>0）且延遲模式(沒有配置nodelay)；如果桶滿了，則新進入的請求被限流；如果沒有滿則請求會以固定平均速率被處理（按照固定速率并根據需要延遲處理請求，延遲使用休眠實作）；

2.3、如果配置了桶容量（burst>0）且非延遲模式（配置了nodelay）；不會按照固定速率處理請求，而是允許突發處理請求；如果桶滿了，則請求被限流，直接傳回相應的錯誤碼；

3、如果沒有被限流，則正常處理請求；

4、Nginx會在相應時機進行選擇一些（3個節點）限流KEY進行過期處理，進行記憶體回收。

場景2.1測試

首先定義IP次元的限流區域：

limit_req_zone $binary_remote_addrzone=test:10m rate=500r/s;

限制為每秒500個請求，固定平均速率為2毫秒一個請求。

接着在要限流的location中添加限流邏輯：

location /limit {

    limit_req zone=test;

    echo "123";

}

即桶容量為0（burst預設為0），且延遲模式。

使用AB測試工具進行測試，并發數為2個，總的請求數為10個：

ab -n 10 -c 2 http://localhost/limit

将得到如下access.log輸出：

[08/Jun/2016:20:25:56+0800] [1465381556.410] 200

[08/Jun/2016:20:25:56 +0800][1465381556.410] 503

[08/Jun/2016:20:25:56 +0800][1465381556.411] 503

[08/Jun/2016:20:25:56+0800] [1465381556.411] 200

[08/Jun/2016:20:25:56 +0800][1465381556.412] 503

[08/Jun/2016:20:25:56 +0800][1465381556.412] 503

雖然每秒允許500個請求，但是因為桶容量為0，是以流入的請求要麼被處理要麼被限流，無法延遲處理；另外平均速率在2毫秒左右，比如1465381556.410和1465381556.411被處理了；有朋友會說這固定平均速率不是1毫秒嘛，其實這是因為實作算法沒那麼精準造成的。

如果被限流在error.log中會看到如下内容：

2016/06/08 20:25:56 [error] 6130#0: *1962limiting requests, excess: 1.000 by zone "test", client: 127.0.0.1,server: _, request: "GET /limit HTTP/1.0", host:"localhost"

如果被延遲了在error.log（日志級别要INFO級别）中會看到如下内容：

2016/06/10 09:05:23 [warn] 9766#0: *97021delaying request, excess: 0.368, by zone "test", client: 127.0.0.1,server: _, request: "GET /limit HTTP/1.0", host:"localhost"

場景2.2測試

首先定義IP次元的限流區域：

limit_req_zone $binary_remote_addr zone=test:10m rate=2r/s;

為了友善測試設定速率為每秒2個請求，即固定平均速率是500毫秒一個請求。

接着在要限流的location中添加限流邏輯：

location /limit {

    limit_req zone=test burst=3;

    echo "123";

}

固定平均速率為500毫秒一個請求，通容量為3，如果桶滿了新的請求被限流，否則可以進入桶中排隊并等待（實作延遲模式）。

為了看出限流效果我們寫了一個req.sh腳本：

ab -c 6 -n 6 http://localhost/limit

sleep 0.3

ab -c 6 -n 6 http://localhost/limit

首先進行6個并發請求6次URL，然後休眠300毫秒，然後再進行6個并發請求6次URL；中間休眠目的是為了能跨越2秒看到效果，如果看不到如下的效果可以調節休眠時間。

将得到如下access.log輸出：

[09/Jun/2016:08:46:43+0800] [1465433203.959] 200

[09/Jun/2016:08:46:43 +0800][1465433203.959] 503

[09/Jun/2016:08:46:43 +0800][1465433203.960] 503

[09/Jun/2016:08:46:44+0800] [1465433204.450] 200

[09/Jun/2016:08:46:44+0800] [1465433204.950] 200

[09/Jun/2016:08:46:45 +0800][1465433205.453] 200

[09/Jun/2016:08:46:45 +0800][1465433205.766] 503

[09/Jun/2016:08:46:45 +0800][1465433205.766] 503

[09/Jun/2016:08:46:45 +0800][1465433205.767] 503

[09/Jun/2016:08:46:45+0800] [1465433205.950] 200

[09/Jun/2016:08:46:46+0800] [1465433206.451] 200

[09/Jun/2016:08:46:46+0800] [1465433206.952] 200

桶容量為3，即桶中在時間視窗内最多流入3個請求，且按照2r/s的固定速率處理請求（即每隔500毫秒處理一個請求）；桶計算時間視窗（1.5秒）=速率（2r/s）/桶容量(3)，也就是說在這個時間視窗内桶最多暫存3個請求。是以我們要以目前時間往前推1.5秒和1秒來計算時間視窗内的總請求數；另外因為預設是延遲模式，是以時間窗内的請求要被暫存到桶中，并以固定平均速率處理請求：

第一輪：有4個請求處理成功了，按照漏桶桶容量應該最多3個才對；這是因為計算算法的問題，第一次計算因沒有參考值，是以第一次計算後，後續的計算才能有參考值，是以第一次成功可以忽略；這個問題影響很小可以忽略；而且按照固定500毫秒的速率處理請求。

第二輪：因為第一輪請求是突發來的，差不多都在1465433203.959時間點，隻是因為漏桶将速率進行了平滑變成了固定平均速率（每500毫秒一個請求）；而第二輪計算時間應基于1465433203.959；而第二輪突發請求差不多都在1465433205.766時間點，是以計算桶容量的時間視窗應基于1465433203.959和1465433205.766來計算，計算結果為1465433205.766這個時間點漏桶為空了，可以流入桶中3個請求，其他請求被拒絕；又因為第一輪最後一次處理時間是1465433205.453，是以第二輪第一個請求被延遲到了1465433205.950。這裡也要注意固定平均速率隻是在配置的速率左右，存在計算精度問題，會有一些偏差。

如果桶容量改為1（burst=1），執行req.sh腳本可以看到如下輸出：

09/Jun/2016:09:04:30+0800] [1465434270.362] 200

[09/Jun/2016:09:04:30 +0800][1465434270.371] 503

[09/Jun/2016:09:04:30 +0800] [1465434270.372]503

[09/Jun/2016:09:04:30 +0800][1465434270.372] 503

[09/Jun/2016:09:04:30 +0800][1465434270.372] 503

[09/Jun/2016:09:04:30+0800] [1465434270.864] 200

[09/Jun/2016:09:04:31 +0800][1465434271.178] 503

[09/Jun/2016:09:04:31 +0800][1465434271.178] 503

[09/Jun/2016:09:04:31 +0800][1465434271.178] 503

[09/Jun/2016:09:04:31 +0800][1465434271.178] 503

[09/Jun/2016:09:04:31 +0800][1465434271.179] 503

[09/Jun/2016:09:04:31+0800] [1465434271.366] 200

桶容量為1，按照每1000毫秒一個請求的固定平均速率處理請求。

場景2.3測試

首先定義IP次元的限流區域：

limit_req_zone $binary_remote_addrzone=test:10m rate=2r/s;

為了友善測試配置為每秒2個請求，固定平均速率是500毫秒一個請求。

接着在要限流的location中添加限流邏輯：

location /limit {

    limit_req zone=test burst=3 nodelay;

    echo "123";

}

桶容量為3，如果桶滿了直接拒絕新請求，且每秒2最多兩個請求，桶按照固定500毫秒的速率以nodelay模式處理請求。

為了看到限流效果我們寫了一個req.sh腳本：

ab -c 6 -n 6 http://localhost/limit

sleep 1

ab -c 6 -n 6 http://localhost/limit

sleep 0.3

ab -c 6 -n 6 http://localhost/limit

sleep 0.3

ab -c 6 -n 6 http://localhost/limit

sleep 0.3

ab -c 6 -n 6 http://localhost/limit

sleep 2

ab -c 6 -n 6 http://localhost/limit

将得到類似如下access.log輸出：

[09/Jun/2016:14:30:11+0800] [1465453811.754] 200

[09/Jun/2016:14:30:11+0800] [1465453811.755] 200

[09/Jun/2016:14:30:11+0800] [1465453811.755] 200

[09/Jun/2016:14:30:11+0800] [1465453811.759] 200

[09/Jun/2016:14:30:11 +0800][1465453811.759] 503

[09/Jun/2016:14:30:11 +0800][1465453811.759] 503

[09/Jun/2016:14:30:12+0800] [1465453812.776] 200

[09/Jun/2016:14:30:12+0800] [1465453812.776] 200

[09/Jun/2016:14:30:12 +0800][1465453812.776] 503

[09/Jun/2016:14:30:12 +0800][1465453812.777] 503

[09/Jun/2016:14:30:12 +0800][1465453812.777] 503

[09/Jun/2016:14:30:12 +0800][1465453812.777] 503

[09/Jun/2016:14:30:13 +0800] [1465453813.095]503

[09/Jun/2016:14:30:13 +0800][1465453813.097] 503

[09/Jun/2016:14:30:13 +0800][1465453813.097] 503

[09/Jun/2016:14:30:13 +0800][1465453813.097] 503

[09/Jun/2016:14:30:13 +0800][1465453813.097] 503

[09/Jun/2016:14:30:13 +0800][1465453813.098] 503

[09/Jun/2016:14:30:13+0800] [1465453813.425] 200

[09/Jun/2016:14:30:13 +0800][1465453813.425] 503

[09/Jun/2016:14:30:13 +0800][1465453813.425] 503

[09/Jun/2016:14:30:13 +0800][1465453813.426] 503

[09/Jun/2016:14:30:13 +0800][1465453813.426] 503

[09/Jun/2016:14:30:13 +0800][1465453813.426] 503

[09/Jun/2016:14:30:13+0800] [1465453813.754] 200

[09/Jun/2016:14:30:13 +0800][1465453813.755] 503

[09/Jun/2016:14:30:13 +0800][1465453813.755] 503

[09/Jun/2016:14:30:13 +0800][1465453813.756] 503

[09/Jun/2016:14:30:13 +0800][1465453813.756] 503

[09/Jun/2016:14:30:13 +0800][1465453813.756] 503

[09/Jun/2016:14:30:15+0800] [1465453815.278] 200

[09/Jun/2016:14:30:15+0800] [1465453815.278] 200

[09/Jun/2016:14:30:15+0800] [1465453815.278] 200

[09/Jun/2016:14:30:15 +0800][1465453815.278] 503

[09/Jun/2016:14:30:15 +0800][1465453815.279] 503

[09/Jun/2016:14:30:15 +0800][1465453815.279] 503

[09/Jun/2016:14:30:17+0800] [1465453817.300] 200

[09/Jun/2016:14:30:17+0800] [1465453817.300] 200

[09/Jun/2016:14:30:17+0800] [1465453817.300] 200

[09/Jun/2016:14:30:17+0800] [1465453817.301] 200

[09/Jun/2016:14:30:17 +0800][1465453817.301] 503

[09/Jun/2016:14:30:17 +0800][1465453817.301] 503

桶容量為3（，即桶中在時間視窗内最多流入3個請求，且按照2r/s的固定速率處理請求（即每隔500毫秒處理一個請求）；桶計算時間視窗（1.5秒）=速率（2r/s）/桶容量(3)，也就是說在這個時間視窗内桶最多暫存3個請求。是以我們要以目前時間往前推1.5秒和1秒來計算時間視窗内的總請求數；另外因為配置了nodelay，是非延遲模式，是以允許時間窗内突發請求的；另外從本示例會看出兩個問題：

第一輪和第七輪：有4個請求處理成功了；這是因為計算算法的問題，本示例是如果2秒内沒有請求，然後接着突然來了很多請求，第一次計算的結果将是不正确的；這個問題影響很小可以忽略；

第五輪：1.0秒計算出來是3個請求；此處也是因計算精度的問題，也就是說limit_req實作的算法不是非常精準的，假設此處看成相對于2.75的話，1.0秒内隻有1次請求，是以還是允許1次請求的。

如果限流出錯了，可以配置錯誤頁面：

proxy_intercept_errors on;

recursive_error_pages on;

error_page 503 //www.jd.com/error.aspx;

limit_conn_zone/limit_req_zone定義的記憶體不足，則後續的請求将一直被限流，是以需要根據需求設定好相應的記憶體大小。

此處的限流都是單Nginx的，假設我們接入層有多個nginx，此處就存在和應用級限流相同的問題；那如何處理呢？一種解決辦法：建立一個負載均衡層将按照限流KEY進行一緻性雜湊演算法将請求哈希到接入層Nginx上，進而相同KEY的将打到同一台接入層Nginx上；另一種解決方案就是使用Nginx+Lua（OpenResty）調用分布式限流邏輯實作。

lua-resty-limit-traffic

之前介紹的兩個子產品使用上比較簡單，指定KEY、指定限流速率等就可以了，如果我們想根據實際情況變化KEY、變化速率、變化桶大小等這種動态特性，使用标準子產品就很難去實作了，是以我們需要一種可程式設計來解決我們問題；而OpenResty提供了lua限流子產品lua-resty-limit-traffic，通過它可以按照更複雜的業務邏輯進行動态限流處理了。其提供了limit.conn和limit.req實作，算法與nginx limit_conn和limit_req是一樣的。

此處我們來實作ngx_http_limit_req_module中的【場景2.2測試】，不要忘記下載下傳lua-resty-limit-traffic子產品并添加到OpenResty的lualib中。

配置用來存放限流用的共享字典：

lua_shared_dict limit_req_store 100m;

以下是實作【場景2.2測試】的限流代碼limit_req.lua：

local limit_req = require "resty.limit.req"

local rate = 2 --固定平均速率 2r/s

local burst = 3 --桶容量

local error_status = 503

local nodelay = false --是否需要不延遲處理

local lim, err = limit_req.new("limit_req_store", rate, burst)

if not lim then --沒定義共享字典

    ngx.exit(error_status)

end

local key = ngx.var.binary_remote_addr --IP次元的限流

--流入請求，如果請求需要被延遲則delay > 0

local delay, err = lim:incoming(key, true)

if not delay and err == "rejected" then --超出桶大小了

    ngx.exit(error_status)

end

if delay > 0 then --根據需要決定是延遲或者不延遲處理

    if nodelay then

        --直接突發處理了

    else

        ngx.sleep(delay) --延遲處理

    end

end

即限流邏輯再nginx access階段被通路，如果不被限流繼續後續流程；如果需要被限流要麼sleep一段時間繼續後續流程，要麼傳回相應的狀态碼拒絕請求。

在分布式限流中我們使用了簡單的Nginx+Lua進行分布式限流，有了這個子產品也可以使用這個子產品來實作分布式限流。

另外在使用Nginx+Lua時也可以擷取ngx.var.connections_active進行過載保護，即如果目前活躍連接配接數超過門檻值進行限流保護。

if tonumber(ngx.var.connections_active) >= tonumber(limit) then

    //限流

end

nginx也提供了limit_rate用來對流量限速，如limit_rate 50k，表示限制下載下傳速度為50k。

到此筆者在工作中涉及的限流用法就介紹完，這些算法中有些允許突發，有些會整形為平滑，有些計算算法簡單粗暴；其中令牌桶算法和漏桶算法實作上是類似的，隻是表述的方向不太一樣，對于業務來說不必刻意去區分它們；是以需要根據實際場景來決定如何限流，最好的算法不一定是最适用的。