令牌桶VS漏桶：誰才是流量控制的“最優解”？ Detail - 後端,java,面試程序員小富 Blog

Stories

Detail

Return

令牌桶VS漏桶：誰才是流量控制的“最優解”？ - Stories Detail

09:57 AM · Nov 03 ,2025

大家好，我是小富～

面試被問到限流算法，很多面試官會讓直接手寫令牌桶和漏桶的實現。雖然平時用過Redis、Guava等現成的限流工具，但真要手寫還是有點慌。今天就來聊聊這兩種經典限流算法的區別，並用Java手寫實現。

很多的限流工具底層都應用了它們

一、令牌桶 vs 漏桶：核心區別

令牌桶

令牌桶的核心思想：固定容量的桶，以固定速率往桶裏放令牌，請求來了就從桶拿令牌，沒令牌就拒絕。

有點像買票進站，想去坐火車就先去售票窗口買票，買到票了就憑票進入，買不到等待，因為窗口會定時的放票，再去搶。

下圖是用Ai生成的，大致能體現出這麼個意思

令牌桶特點：

1、可以處理突發流量（桶裏有令牌就能用），因為並不是一直請求都很多，但會一直以固定速率向桶裏添加令牌，請求少時桶內令牌滿了，請求激增可以滿桶拿令牌頂一陣

2、原理和實現上相對簡單

3、內存佔用小

漏桶適用場景：

接口限流：保護業務系統或者敏感接口

防止惡意攻擊：抵禦Dos或DDos攻擊

……
它的優勢在於能夠限制平均速率，同時允許一定的突發流量

漏桶

漏桶的核心思想比令牌桶早更簡單：請求像水一樣流入桶中，桶以固定速率“漏水”處理請求，超出桶容量的請求被丟棄或排隊。

漏桶的特點：

1、輸出非常平滑穩定

2、能有效保護下游系統（流量平滑）

3、❌ 無法處理突發流量

4、❌ 可能造成請求延遲

漏桶適用場景：

數據庫連接池：保護數據庫不被過載

消息隊列消費：控制消費速率

支付系統：確保支付處理穩定性

二、手寫實現

令牌桶實現

public class TokenBucket {
    // 桶容量（最大令牌數）
    privatefinallong capacity;
    // 令牌填充速率（令牌/秒）
    privatefinallong refillRate;
    // 當前令牌數量
    private AtomicLong tokens;
    // 上次填充時間戳（納秒）
    privatelong lastRefillTime;

    public TokenBucket(long capacity, long refillRate) {
        this.capacity = capacity;
        this.refillRate = refillRate;
        this.tokens = new AtomicLong(capacity);
        this.lastRefillTime = System.nanoTime();
    }

    // 示例使用
    public static void main(String[] args) throws InterruptedException {
        // 創建桶：容量10令牌，每秒填充5令牌
        TokenBucket bucket = new TokenBucket(10, 2);

        // 模擬請求
        for (int i = 1; i <= 50; i++) {
            if (bucket.tryAcquire()) {
                System.out.println("請求" + i + ": 通過");
            } else {
                System.out.println("請求" + i + ": 限流");
            }
            Thread.sleep(100); // 100ms請求一次
        }
    }

    /**
     * 嘗試獲取令牌
     *
     * @return true-獲取成功，false-被限流
     */
    public synchronized boolean tryAcquire() {
        refillTokens();
        if (tokens.get() > 0) {
            tokens.decrementAndGet();
            returntrue;
        }
        returnfalse;
    }

    /**
     * 嘗試獲取多個令牌
     *
     * @param numTokens 請求令牌數
     */
    public synchronized boolean tryAcquire(int numTokens) {
        refillTokens();
        if (tokens.get() >= numTokens) {
            tokens.addAndGet(-numTokens);
            returntrue;
        }
        returnfalse;
    }

    // 根據時間差補充令牌
    private void refillTokens() {
        long now = System.nanoTime();
        // 計算時間差（秒）
        double elapsedSec = (now - lastRefillTime) * 1e-9;

        // 計算應補充的令牌數
        long tokensToAdd = (long) (elapsedSec * refillRate);
        if (tokensToAdd > 0) {
            tokens.set(Math.min(capacity, tokens.get() + tokensToAdd));
            lastRefillTime = now;
        }
    }
}

使用 AtomicLong 保證線程安全。
通過時間差動態計算補充的令牌數。
桶容量限制突發流量的最大值。

漏桶實現

import java.util.concurrent.atomic.AtomicLong;

publicclass LeakyBucket {
    // 桶容量（最大請求數）
    privatefinallong capacity;
    // 漏水速率（請求/秒）
    privatefinallong leakRate;
    // 當前水量（待處理請求數）
    private AtomicLong water;
    // 上次漏水時間戳（毫秒）
    privatelong lastLeakTime;

    public LeakyBucket(long capacity, long leakRate) {
        this.capacity = capacity;
        this.leakRate = leakRate;
        this.water = new AtomicLong(0);
        this.lastLeakTime = System.currentTimeMillis();
    }

    // 示例使用
    public static void main(String[] args) throws InterruptedException {
        // 創建桶：容量5請求，每秒處理2請求
        LeakyBucket bucket = new LeakyBucket(5, 1);

        // 模擬請求
        for (int i = 1; i <= 15; i++) {
            if (bucket.tryPass()) {
                System.out.println("請求" + i + ": 通過 (當前水位: " + bucket.water.get() + ")");
            } else {
                System.out.println("請求" + i + ": 限流 (水位溢出)");
            }
            Thread.sleep(200); // 200ms請求一次
        }
    }

    /**
     * 嘗試通過漏桶
     *
     * @return true-允許通過，false-被限流
     */
    public synchronized boolean tryPass() {
        leakWater();
        if (water.get() < capacity) {
            water.incrementAndGet();
            returntrue;
        }
        returnfalse;
    }

    // 根據時間差漏水
    private void leakWater() {
        long now = System.currentTimeMillis();
        // 計算時間差（秒）
        long elapsedMs = now - lastLeakTime;
        if (elapsedMs > 0) {
            // 計算漏水量
            long leaked = (long) (elapsedMs * leakRate / 1000.0);
            if (leaked > 0) {
                water.updateAndGet(cur -> Math.max(0, cur - leaked));
                lastLeakTime = now;
            }
        }
    }
}

漏出速率固定，確保請求處理平滑。
水量超過容量時直接拒絕請求。

三、測試對比

public class RateLimiterTest {
    public static void main(String[] args) throws InterruptedException {
        // 測試令牌桶：容量10，每秒填充5個令牌
        TokenBucket tokenBucket = new TokenBucket(10, 5);

        // 測試漏桶：容量10，每秒漏出5個請求
        LeakyBucket leakyBucket = new LeakyBucket(10, 5);

        System.out.println("=== 令牌桶測試（支持突發） ===");
        testTokenBucket(tokenBucket);

        Thread.sleep(1000);

        System.out.println("\n=== 漏桶測試（平滑輸出） ===");
        testLeakyBucket(leakyBucket);
    }

    private static void testTokenBucket(TokenBucket bucket) {
        // 模擬突發請求
        for (int i = 0; i < 15; i++) {
            boolean success = bucket.tryConsume(1);
            System.out.printf("請求%d: %s (當前令牌: %.1f)%n", 
                i + 1, success ? "通過" : "拒絕", bucket.getCurrentTokens());
        }
    }

    private static void testLeakyBucket(LeakyBucket bucket) {
        // 模擬突發請求
        for (int i = 0; i < 15; i++) {
            boolean success = bucket.tryConsume();
            System.out.printf("請求%d: %s (當前水量: %.1f)%n", 
                i + 1, success ? "通過" : "拒絕", bucket.getCurrentWater());
        }
    }
}