面試必備：4 種經典限流算法講解

最近，我們的業務系統引入了 Guava 的 RateLimiter 限流組件，它是基於令牌桶算法實現的, 而令牌桶是非常經典的限流算法。本文將跟大家一起學習幾種經典的限流算法。

• 公衆號: 撿田螺的小男孩

限流是什麼?

維基百科的概念如下：

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

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

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

★

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

”

常見的限流算法

固定窗口限流算法

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

• 當次數少於限流閥值，就允許訪問，並且計數器 + 1

• 當次數大於限流閥值，就拒絕訪問。

• 當前的時間窗口過去之後，計數器清零。

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

僞代碼如下：

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

        return false;
    }

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

滑動窗口限流算法

滑動窗口限流解決固定窗口臨界值的問題。它將單位時間週期分爲 n 個小週期，分別記錄每個小週期內接口的訪問次數，並且根據時間滑動刪除過期的小週期。

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

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

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

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

TIPS: 當滑動窗口的格子週期劃分的越多，那麼滑動窗口的滾動就越平滑，限流的統計就會越精確。

滑動窗口算法僞代碼實現如下：

 /**
     * 單位時間劃分的小週期（單位時間是1分鐘，10s一個小格子窗口，一共6個格子）
     */
    private int SUB_CYCLE = 10;

    /**
     * 每分鐘限流請求數
     */
    private int thresholdPerMin = 100;

    /**
     * 計數器, k-爲當前窗口的開始時間值秒，value爲當前窗口的計數
     */
    private final TreeMap<Long, Integer> counters = new TreeMap<>();

   /**
     * 滑動窗口時間算法實現
     */
    boolean slidingWindowsTryAcquire() {
        long currentWindowTime = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC) / SUB_CYCLE * SUB_CYCLE; //獲取當前時間在哪個小週期窗口
        int currentWindowNum = countCurrentWindow(currentWindowTime); //當前窗口總請求數

        //超過閥值限流
        if (currentWindowNum >= thresholdPerMin) {
            return false;
        }

        //計數器+1
        counters.get(currentWindowTime)++;
        return true;
    }

   /**
    * 統計當前窗口的請求數
    */
    private int countCurrentWindow(long currentWindowTime) {
        //計算窗口開始位置
        long startTime = currentWindowTime - SUB_CYCLE* (60s/SUB_CYCLE-1);
        int count = 0;

        //遍歷存儲的計數器
        Iterator<Map.Entry<Long, Integer>> iterator = counters.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Long, Integer> entry = iterator.next();
            // 刪除無效過期的子窗口計數器
            if (entry.getKey() < startTime) {
                iterator.remove();
            } else {
                //累加當前窗口的所有計數器之和
                count =count + entry.getValue();
            }
        }
        return count;
    }

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

漏桶算法

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

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

• 流入的水滴，可以看作是訪問系統的請求，這個流入速率是不確定的。

• 桶的容量一般表示系統所能處理的請求數。

• 如果桶的容量滿了，就達到限流的閥值，就會丟棄水滴（拒絕請求）

• 流出的水滴，是恆定過濾的，對應服務按照固定的速率處理請求。

漏桶算法僞代碼實現如下：

 /**
     * 每秒處理數（出水率）
     */
    private long rate;

    /**
     *  當前剩餘水量
     */
    private long currentWater;

    /**
     * 最後刷新時間
     */
    private long refreshTime;

    /**
     * 桶容量
     */
    private long capacity;

    /**
     * 漏桶算法
     * @return
     */
    boolean leakybucketLimitTryAcquire() {
        long currentTime = System.currentTimeMillis();  //獲取系統當前時間
        long outWater = (currentTime - refreshTime) / 1000 * rate; //流出的水量 =(當前時間-上次刷新時間)* 出水率
        long currentWater = Math.max(0, currentWater - outWater); // 當前水量 = 之前的桶內水量-流出的水量
        refreshTime = currentTime; // 刷新時間

        // 當前剩餘水量還是小於桶的容量，則請求放行
        if (currentWater < capacity) {
            currentWater++;
            return true;
        }
        
        // 當前剩餘水量大於等於桶的容量，限流
        return false;
    }

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

令牌桶算法

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

令牌桶算法原理：

• 有一個令牌管理員，根據限流大小，定速往令牌桶裏放令牌。

• 如果令牌數量滿了，超過令牌桶容量的限制，那就丟棄。

• 系統在接受到一個用戶請求時，都會先去令牌桶要一個令牌。如果拿到令牌，那麼就處理這個請求的業務邏輯；

• 如果拿不到令牌，就直接拒絕這個請求。

漏桶算法僞代碼實現如下：

    /**
     * 每秒處理數（放入令牌數量）
     */
    private long putTokenRate;
    
    /**
     * 最後刷新時間
     */
    private long refreshTime;

    /**
     * 令牌桶容量
     */
    private long capacity;
    
    /**
     * 當前桶內令牌數
     */
    private long currentToken = 0L;

    /**
     * 漏桶算法
     * @return
     */
    boolean tokenBucketTryAcquire() {

        long currentTime = System.currentTimeMillis();  //獲取系統當前時間
        long generateToken = (currentTime - refreshTime) / 1000 * putTokenRate; //生成的令牌 =(當前時間-上次刷新時間)* 放入令牌的速率
        currentToken = Math.min(capacity, generateToken + currentToken); // 當前令牌數量 = 之前的桶內令牌數量+放入的令牌數量
        refreshTime = currentTime; // 刷新時間
        
        //桶裏面還有令牌，請求正常處理
        if (currentToken > 0) {
            currentToken--; //令牌數量-1
            return true;
        }
        
        return false;
    }

如果令牌發放的策略正確，這個系統即不會被拖垮，也能提高機器的利用率。Guava 的 RateLimiter 限流組件，就是基於令牌桶算法實現的。

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/tlaL0ByrWVQ0qiDssSPWnQ