Java常見的限流方案及實現(xiàn)方法

更新時間：2025年05月23日 08:30:30 作者：SHENKEM

高并發(fā)場景中限流是保護系統(tǒng)的重要手段,涵蓋計數(shù)器、滑動窗口、漏桶、令牌桶等算法,這篇文章主要介紹了Java常見的限流方案及實現(xiàn)的相關資料,文中通過代碼介紹的非常詳細,需要的朋友可以參考下

1. 限流的常見算法

1.1 計數(shù)器算法

原理：在固定時間窗口內(nèi)統(tǒng)計請求次數(shù)，超過閾值則拒絕請求。
優(yōu)點：實現(xiàn)簡單。
缺點：無法應對突發(fā)流量。

1.2 滑動窗口算法

原理：將時間窗口劃分為多個小窗口，統(tǒng)計最近一段時間內(nèi)的請求次數(shù)。
優(yōu)點：比計數(shù)器算法更平滑。
缺點：實現(xiàn)復雜。

1.3 漏桶算法

原理：請求以固定速率流出，超過桶容量的請求被丟棄或等待。
優(yōu)點：平滑流量。
缺點：無法應對突發(fā)流量。

1.4 令牌桶算法

原理：以固定速率生成令牌，請求需要獲取令牌才能被處理。
優(yōu)點：支持突發(fā)流量。
缺點：實現(xiàn)復雜。

2. 限流方案的 Java 實現(xiàn)

以下是基于 計數(shù)器算法 和 令牌桶算法 的 Java 實現(xiàn)示例。

2.1 計數(shù)器算法實現(xiàn)

import java.util.concurrent.atomic.AtomicInteger;

public class CounterRateLimiter {
    private final int limit; // 限流閾值
    private final long interval; // 時間窗口（毫秒）
    private final AtomicInteger counter; // 計數(shù)器
    private long lastResetTime; // 上次重置時間

    public CounterRateLimiter(int limit, long interval) {
        this.limit = limit;
        this.interval = interval;
        this.counter = new AtomicInteger(0);
        this.lastResetTime = System.currentTimeMillis();
    }

    public boolean tryAcquire() {
        long now = System.currentTimeMillis();
        if (now - lastResetTime > interval) {
            // 重置計數(shù)器
            counter.set(0);
            lastResetTime = now;
        }
        // 判斷是否超過閾值
        return counter.incrementAndGet() <= limit;
    }

    public static void main(String[] args) throws InterruptedException {
        CounterRateLimiter limiter = new CounterRateLimiter(10, 1000); // 每秒限流 10 次
        for (int i = 0; i < 20; i++) {
            System.out.println("請求 " + i + ": " + (limiter.tryAcquire() ? "通過" : "被限流"));
            Thread.sleep(100); // 模擬請求間隔
        }
    }
}

2.2 令牌桶算法實現(xiàn)

import java.util.concurrent.atomic.AtomicLong;

public class TokenBucketRateLimiter {
    private final long capacity; // 桶容量
    private final long rate; // 令牌生成速率（令牌/毫秒）
    private final AtomicLong tokens; // 當前令牌數(shù)量
    private long lastRefillTime; // 上次補充令牌時間

    public TokenBucketRateLimiter(long capacity, long rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.tokens = new AtomicLong(capacity);
        this.lastRefillTime = System.currentTimeMillis();
    }

    public boolean tryAcquire() {
        refillTokens(); // 補充令牌
        long currentTokens = tokens.get();
        if (currentTokens > 0) {
            return tokens.decrementAndGet() >= 0;
        }
        return false;
    }

    private void refillTokens() {
        long now = System.currentTimeMillis();
        long elapsedTime = now - lastRefillTime;
        long newTokens = elapsedTime * rate; // 計算新增令牌數(shù)
        if (newTokens > 0) {
            lastRefillTime = now;
            tokens.updateAndGet(old -> Math.min(capacity, old + newTokens)); // 更新令牌數(shù)
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TokenBucketRateLimiter limiter = new TokenBucketRateLimiter(10, 1); // 桶容量 10，每秒生成 1 個令牌
        for (int i = 0; i < 20; i++) {
            System.out.println("請求 " + i + ": " + (limiter.tryAcquire() ? "通過" : "被限流"));
            Thread.sleep(100); // 模擬請求間隔
        }
    }
}

3. 使用 Guava 的 RateLimiter

Google Guava 提供了 RateLimiter 類，基于令牌桶算法實現(xiàn)限流。

3.1 添加依賴

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0.1-jre</version>
</dependency>

運行 HTML

3.2 使用示例

import com.google.common.util.concurrent.RateLimiter;

public class GuavaRateLimiterExample {
    public static void main(String[] args) throws InterruptedException {
        RateLimiter limiter = RateLimiter.create(1.0); // 每秒限流 1 次
        for (int i = 0; i < 10; i++) {
            System.out.println("請求 " + i + ": " + (limiter.tryAcquire() ? "通過" : "被限流"));
            Thread.sleep(300); // 模擬請求間隔
        }
    }
}

4. 限流方案的選擇

算法	優(yōu)點	缺點	適用場景
計數(shù)器	實現(xiàn)簡單	無法應對突發(fā)流量	簡單限流場景
滑動窗口	比計數(shù)器更平滑	實現(xiàn)復雜	需要平滑限流的場景
漏桶	平滑流量	無法應對突發(fā)流量	需要嚴格控制流量的場景
令牌桶	支持突發(fā)流量	實現(xiàn)復雜	需要支持突發(fā)流量的場景
Guava	簡單易用，功能強大	依賴第三方庫	需要快速實現(xiàn)限流的場景