首頁  >  文章  >  Java  >  Java中經典限流演算法實例分析

Java中經典限流演算法實例分析

王林
王林轉載
2023-04-18 23:13:01932瀏覽

限流是什麼?

維基百科的概念如下:

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,重新開始計數。如下圖:

Java中經典限流演算法實例分析

偽代碼如下:

    /**
     * 固定窗口时间算法
     * @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閥值的定義啦。

Java中經典限流演算法實例分析

##滑動視窗限流演算法

滑動視窗限流解決固定視窗臨界值的問題。它將單位時間週期分為n個小週期,分別記錄每個小週期內介面的存取次數,並且根據時間滑動刪除過期的小週期。

一張圖解釋滑動視窗演算法,如下:

Java中經典限流演算法實例分析

假設單位時間還是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;
    }

滑動視窗演算法雖然解決了

固定視窗的臨界問題,但一旦到達限流後,請求都會直接暴力被拒絕。醬紫我們會損失一部分請求,這其實對於產品來說,並不太友善。

漏桶演算法

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

它的原理很簡單,可以認為就是

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

Java中經典限流演算法實例分析

  • 流入的水滴,可以看成是存取系統的請求,這個流入速率是不確定的。

  • 桶的容量一般表示系统所能处理的请求数。

  • 如果桶的容量满了,就达到限流的阀值,就会丢弃水滴(拒绝请求)

  • 流出的水滴,是恒定过滤的,对应服务按照固定的速率处理请求。

漏桶算法伪代码实现如下:

 /**
     * 每秒处理数(出水率)
     */
    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;
    }

在正常流量的时候,系统按照固定的速率处理请求,是我们想要的。但是面对突发流量的时候,漏桶算法还是循规蹈矩地处理请求,这就不是我们想看到的啦。流量变突发时,我们肯定希望系统尽量快点处理请求,提升用户体验嘛。

令牌桶算法

面对突发流量的时候,我们可以使用令牌桶算法限流。

令牌桶算法原理

  • 有一个令牌管理员,根据限流大小,定速往令牌桶里放令牌。

  • 如果令牌数量满了,超过令牌桶容量的限制,那就丢弃。

  • 系统在接受到一个用户请求时,都会先去令牌桶要一个令牌。如果拿到令牌,那么就处理这个请求的业务逻辑;

  • 如果拿不到令牌,就直接拒绝这个请求。

Java中經典限流演算法實例分析

漏桶算法伪代码实现如下:

    /**
     * 每秒处理数(放入令牌数量)
     */
    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限流组件,就是基于令牌桶算法实现的。

以上是Java中經典限流演算法實例分析的詳細內容。更多資訊請關注PHP中文網其他相關文章!

陳述:
本文轉載於:yisu.com。如有侵權,請聯絡admin@php.cn刪除