漏斗桶和令牌桶

 漏斗桶和令牌桶都屬於服務端常用的限流手段

漏斗桶

如圖：把請求比作水，漏斗有一個進水口 和 一個出水口，出水口以一定速率出水，並且有一個最大出水速率，當桶里有水並且一直在進水時，就會直接溢出（拒絕服務）

優點：能夠強行限制數據的傳輸速度，因為流出速率為固定值，能夠讓自身的流量平穩的打到下游的接口上，所以對下游系統起到保護作用

缺點：沒有有效的使用網絡資源，因為流出速率為固定值，即使部分網絡為空閑，也無法接收到請求，因此，漏桶算法對於突發特性的流量來說缺乏效率。

比如某一個時刻有10個請求，漏斗桶的流出速率為2，漏斗容量為5，那么將會有5個請求被拒絕，漏斗中的5個按照2的速率處理。

public class FunnelBucketTest {

    //漏斗桶的容量
    private final int capacity = 5;

    //漏斗桶的流出速率
    private int rate;

    //剩余容量
    private int leaveCap = 0;

    //漏斗桶中請求的存儲
    private LinkedList<SimulationRequest> requestList = new LinkedList<>();


    public FunnelBucketTest(final int rate) {
        this.rate = rate;

        //初始化時，leaveCap為桶的容量
        leaveCap = capacity;

        new Thread(new Runnable() {
            public void run() {
                while(true){
                    if (!requestList.isEmpty()){
                        SimulationRequest simulationRequest = requestList.removeFirst();
                        System.out.println("第"+simulationRequest.getI()+"個請求被處理");
                    }

                    //這里設置每秒處理幾個
                    try {
                        Thread.sleep(1000/rate);
                    }catch (Exception e){
                        System.out.println("error");
                    }
                }
            }
        }).start();
    }

    public synchronized boolean tryAcqure(SimulationRequest request){
        if (leaveCap <=0){
            return false;
        } else {
            leaveCap--;
            requestList.add(request);
            return true;
        }
    }

    public static void main(String[] args) {
        FunnelBucketTest funnelBucketTest = new FunnelBucketTest(2);
        for (int i = 1 ; i <=10;i++){
            SimulationRequest simulationRequest = new SimulationRequest(i);
            if (funnelBucketTest.tryAcqure(simulationRequest)){
                System.out.println("第"+simulationRequest.getI()+"個請求成功執行");
            } else {
                System.out.println("第"+simulationRequest.getI()+"個請求被拒絕");
            }
        }
    }


    //模擬請求對象
    static class SimulationRequest{

        /**
         * 當前為第幾個
         */
        private int i;

        public SimulationRequest(int i) {
            this.i = i;
        }

        public int getI() {
            return i;
        }

        public void setI(int i) {
            this.i = i;
        }
    }
}

 

令牌桶

 

 

令牌桶是系統以恆定的速率產生令牌，令牌桶有個容量，當令牌桶滿了之后，再放入令牌會被丟棄；當處理一個請求時，會從令牌桶中取出一個令牌，如果拿到了令牌，那么請求會被處理，否則請求會被丟棄。

相比漏斗桶的優點

令牌桶同樣可以做到限制流量；

令牌桶對突發流量，有比較好的處理，比如：還是同一時刻有10個請求，令牌桶的大小為5，同樣也是拒絕5個請求，但是令牌桶可以瞬間放過5個請求，而漏斗桶卻實際處理1個，所以單從瞬間的話，令牌桶處理了更多的請求。

令牌桶算法一般用於保護自身的系統，對調用者進行限流，保護自身的系統不被突發的流量打垮

模仿令牌桶：

public class TokenBucketTest {

    //令牌桶容量
    private final int capacity = 5;

    //令牌產生速率
    private int rate;

    //令牌的剩余數量
    private int leaveCap = 0;

    public TokenBucketTest(final int rate) {
        this.rate = rate;

        //設置令牌剩余數量為容量
        leaveCap = capacity;

        new Thread(new Runnable() {
            public void run() {
                while (true) {
                    leaveCap++;
                    if (leaveCap > capacity){
                        leaveCap = capacity;
                    }
                    //這里設置每秒增加幾個令牌
                    try {
                        Thread.sleep(1000/rate);
                    }catch (Exception e){
                        System.out.println("error");
                    }
                }
            }
        }).start();
    }

    public synchronized boolean tryAcqure(FunnelBucketTest.SimulationRequest request){
        if (leaveCap <=0){
            return false;
        } else {
            leaveCap--;
            return true;
        }
    }

    public static void main(String[] args) {
        TokenBucketTest funnelBucketTest = new TokenBucketTest(2);
        for (int i = 1 ; i <=10;i++){
            FunnelBucketTest.SimulationRequest simulationRequest = new FunnelBucketTest.SimulationRequest(i);
            if (funnelBucketTest.tryAcqure(simulationRequest)){
                System.out.println("第"+simulationRequest.getI()+"個請求成功執行");
            } else {
                System.out.println("第"+simulationRequest.getI()+"個請求被拒絕");
            }
        }
    }
}

 

比較常用的令牌桶的實現方式：Ratelimiter,使用方式參考：http://ifeve.com/guava-ratelimiter/

參考：

秒殺系統的設計方案：https://blog.csdn.net/weixin_43188031/article/details/108304960

《消息隊列高手課》

https://blog.csdn.net/Px01Ih8/article/details/108764655