[[402482]]

最近，我們的業(yè)務(wù)系統(tǒng)引入了Guava的RateLimiter限流組件，它是基于令牌桶算法實現(xiàn)的,而令牌桶是非常經(jīng)典的限流算法。本文將跟大家一起學(xué)習(xí)幾種經(jīng)典的限流算法。

限流是什么?

維基百科的概念如下：

• In computer networks, rate limiting is used to control the rate of requests sent or
• received by a network interface controller. It can be used to prevent DoS attacks
• and limit web scraping

簡單翻譯一下：在計算機網(wǎng)絡(luò)中，限流就是控制網(wǎng)絡(luò)接口發(fā)送或接收請求的速率，它可防止DoS攻擊和限制Web爬蟲。

限流，也稱流量控制。是指系統(tǒng)在面臨高并發(fā)，或者大流量請求的情況下，限制新的請求對系統(tǒng)的訪問，從而保證系統(tǒng)的穩(wěn)定性。限流會導(dǎo)致部分用戶請求處理不及時或者被拒，這就影響了用戶體驗。所以一般需要在系統(tǒng)穩(wěn)定和用戶體驗之間平衡一下。舉個生活的例子：

★一些熱門的旅游景區(qū)，一般會對每日的旅游參觀人數(shù)有限制的。每天只會賣出固定數(shù)目的門票，比如5000張。假設(shè)在五一、國慶假期，你去晚了，可能當天的票就已經(jīng)賣完了，就無法進去游玩了。即使你進去了，排隊也能排到你懷疑人生。”

常見的限流算法

固定窗口限流算法

首先維護一個計數(shù)器，將單位時間段當做一個窗口，計數(shù)器記錄這個窗口接收請求的次數(shù)。

• 當次數(shù)少于限流閥值，就允許訪問，并且計數(shù)器+1
• 當次數(shù)大于限流閥值，就拒絕訪問。
• 當前的時間窗口過去之后，計數(shù)器清零。

假設(shè)單位時間是1秒，限流閥值為3。在單位時間1秒內(nèi)，每來一個請求,計數(shù)器就加1，如果計數(shù)器累加的次數(shù)超過限流閥值3，后續(xù)的請求全部拒絕。等到1s結(jié)束后，計數(shù)器清0，重新開始計數(shù)。如下圖：

偽代碼如下：

/** 
  * 固定窗口時間算法 
  * @return 
  */ 
 boolean fixedWindowsTryAcquire() { 
     long currentTime = System.currentTimeMillis();  //獲取系統(tǒng)當前時間 
     if (currentTime - lastRequestTime > windowUnit) {  //檢查是否在時間窗口內(nèi) 
         counter = 0;  // 計數(shù)器清0 
         lastRequestTime = currentTime;  //開啟新的時間窗口 
     } 
     if (counter < threshold) {  // 小于閥值 
         counter++;  //計數(shù)器加1 
         return true; 
     } 
 
     return false; 
 } 

但是，這種算法有一個很明顯的臨界問題：假設(shè)限流閥值為5個請求，單位時間窗口是1s,如果我們在單位時間內(nèi)的前0.8-1s和1-1.2s，分別并發(fā)5個請求。雖然都沒有超過閥值，但是如果算0.8-1.2s,則并發(fā)數(shù)高達10，已經(jīng)超過單位時間1s不超過5閥值的定義啦。

滑動窗口限流算法

滑動窗口限流解決固定窗口臨界值的問題。它將單位時間周期分為n個小周期，分別記錄每個小周期內(nèi)接口的訪問次數(shù)，并且根據(jù)時間滑動刪除過期的小周期。

一張圖解釋滑動窗口算法，如下：

假設(shè)單位時間還是1s，滑動窗口算法把它劃分為5個小周期，也就是滑動窗口(單位時間)被劃分為5個小格子。每格表示0.2s。每過0.2s，時間窗口就會往右滑動一格。然后呢，每個小周期，都有自己獨立的計數(shù)器，如果請求是0.83s到達的，0.8~1.0s對應(yīng)的計數(shù)器就會加1。

我們來看下滑動窗口是如何解決臨界問題的?

假設(shè)我們1s內(nèi)的限流閥值還是5個請求，0.8~1.0s內(nèi)(比如0.9s的時候)來了5個請求，落在黃色格子里。時間過了1.0s這個點之后，又來5個請求，落在紫色格子里。如果是固定窗口算法，是不會被限流的，但是滑動窗口的話，每過一個小周期，它會右移一個小格。過了1.0s這個點后，會右移一小格，當前的單位時間段是0.2~1.2s，這個區(qū)域的請求已經(jīng)超過限定的5了，已觸發(fā)限流啦，實際上，紫色格子的請求都被拒絕啦。

TIPS: 當滑動窗口的格子周期劃分的越多，那么滑動窗口的滾動就越平滑，限流的統(tǒng)計就會越精確。

滑動窗口算法偽代碼實現(xiàn)如下：

/** 
    * 單位時間劃分的小周期（單位時間是1分鐘，10s一個小格子窗口，一共6個格子） 
    */ 
   private int SUB_CYCLE = 10; 
 
   /** 
    * 每分鐘限流請求數(shù) 
    */ 
   private int thresholdPerMin = 100; 
 
   /** 
    * 計數(shù)器, k-為當前窗口的開始時間值秒，value為當前窗口的計數(shù) 
    */ 
   private final TreeMap<Long, Integer> counters = new TreeMap<>(); 
 
  /** 
    * 滑動窗口時間算法實現(xiàn) 
    */ 
   boolean slidingWindowsTryAcquire() { 
       long currentWindowTime = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC) / SUB_CYCLE * SUB_CYCLE; //獲取當前時間在哪個小周期窗口 
       int currentWindowNum = countCurrentWindow(currentWindowTime); //當前窗口總請求數(shù) 
 
       //超過閥值限流 
       if (currentWindowNum >= thresholdPerMin) { 
           return false; 
       } 
 
       //計數(shù)器+1 
       counters.get(currentWindowTime)++; 
       return true; 
   } 
 
  /** 
   * 統(tǒng)計當前窗口的請求數(shù) 
   */ 
   private int countCurrentWindow(long currentWindowTime) { 
       //計算窗口開始位置 
       long startTime = currentWindowTime - SUB_CYCLE* (60s/SUB_CYCLE-1); 
       int count = 0; 
 
       //遍歷存儲的計數(shù)器 
       Iterator<Map.Entry<Long, Integer>> iterator = counters.entrySet().iterator(); 
       while (iterator.hasNext()) { 
           Map.Entry<Long, Integer> entry = iterator.next(); 
           // 刪除無效過期的子窗口計數(shù)器 
           if (entry.getKey() < startTime) { 
               iterator.remove(); 
           } else { 
               //累加當前窗口的所有計數(shù)器之和 
               count =count + entry.getValue(); 
           } 
       } 
       return count; 
   } 

滑動窗口算法雖然解決了固定窗口的臨界問題，但是一旦到達限流后，請求都會直接暴力被拒絕。醬紫我們會損失一部分請求，這其實對于產(chǎn)品來說，并不太友好。

漏桶算法

漏桶算法面對限流，就更加的柔性，不存在直接的粗暴拒絕。

它的原理很簡單，可以認為就是注水漏水的過程。往漏桶中以任意速率流入水，以固定的速率流出水。當水超過桶的容量時，會被溢出，也就是被丟棄。因為桶容量是不變的，保證了整體的速率。

• 流入的水滴，可以看作是訪問系統(tǒng)的請求，這個流入速率是不確定的。
• 桶的容量一般表示系統(tǒng)所能處理的請求數(shù)。
• 如果桶的容量滿了，就達到限流的閥值，就會丟棄水滴(拒絕請求)
• 流出的水滴，是恒定過濾的，對應(yīng)服務(wù)按照固定的速率處理請求。

漏桶算法偽代碼實現(xiàn)如下：

/** 
    * 每秒處理數(shù)（出水率） 
    */ 
   private long rate; 
 
   /** 
    *  當前剩余水量 
    */ 
   private long currentWater; 
 
   /** 
    * 最后刷新時間 
    */ 
   private long refreshTime; 
 
   /** 
    * 桶容量 
    */ 
   private long capacity; 
 
   /** 
    * 漏桶算法 
    * @return 
    */ 
   boolean leakybucketLimitTryAcquire() { 
       long currentTime = System.currentTimeMillis();  //獲取系統(tǒng)當前時間 
       long outWater = (currentTime - refreshTime) / 1000 * rate; //流出的水量 =(當前時間-上次刷新時間)* 出水率 
       long currentWater = Math.max(0, currentWater - outWater); // 當前水量 = 之前的桶內(nèi)水量-流出的水量 
       refreshTime = currentTime; // 刷新時間 
 
       // 當前剩余水量還是小于桶的容量，則請求放行 
       if (currentWater < capacity) { 
           currentWater++; 
           return true; 
       } 
        
       // 當前剩余水量大于等于桶的容量，限流 
       return false; 
   } 

在正常流量的時候，系統(tǒng)按照固定的速率處理請求，是我們想要的。但是面對突發(fā)流量的時候，漏桶算法還是循規(guī)蹈矩地處理請求，這就不是我們想看到的啦。流量變突發(fā)時，我們肯定希望系統(tǒng)盡量快點處理請求，提升用戶體驗嘛。

令牌桶算法

面對突發(fā)流量的時候，我們可以使用令牌桶算法限流。

令牌桶算法原理：

• 有一個令牌管理員，根據(jù)限流大小，定速往令牌桶里放令牌。
• 如果令牌數(shù)量滿了，超過令牌桶容量的限制，那就丟棄。
• 系統(tǒng)在接受到一個用戶請求時，都會先去令牌桶要一個令牌。如果拿到令牌，那么就處理這個請求的業(yè)務(wù)邏輯;
• 如果拿不到令牌，就直接拒絕這個請求。

漏桶算法偽代碼實現(xiàn)如下：

/** 
  * 每秒處理數(shù)（放入令牌數(shù)量） 
  */ 
 private long putTokenRate; 
  
 /** 
  * 最后刷新時間 
  */ 
 private long refreshTime; 
 
 /** 
  * 令牌桶容量 
  */ 
 private long capacity; 
  
 /** 
  * 當前桶內(nèi)令牌數(shù) 
  */ 
 private long currentToken = 0L; 
 
 /** 
  * 漏桶算法 
  * @return 
  */ 
 boolean tokenBucketTryAcquire() { 
 
     long currentTime = System.currentTimeMillis();  //獲取系統(tǒng)當前時間 
     long generateToken = (currentTime - refreshTime) / 1000 * putTokenRate; //生成的令牌 =(當前時間-上次刷新時間)* 放入令牌的速率 
     currentToken = Math.min(capacity, generateToken + currentToken); // 當前令牌數(shù)量 = 之前的桶內(nèi)令牌數(shù)量+放入的令牌數(shù)量 
     refreshTime = currentTime; // 刷新時間 
      
     //桶里面還有令牌，請求正常處理 
     if (currentToken > 0) { 
         currentToken--; //令牌數(shù)量-1 
         return true; 
     } 
      
     return false; 
 } 

如果令牌發(fā)放的策略正確，這個系統(tǒng)即不會被拖垮，也能提高機器的利用率。Guava的RateLimiter限流組件，就是基于令牌桶算法實現(xiàn)的。

本文轉(zhuǎn)載自微信公眾號「撿田螺的小男孩」，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系撿田螺的小男孩公眾號。