Java常见的限流方案及实现方法

import java.util.concurrent.atomic.AtomicInteger;

public class CounterRateLimiter {
    private final int limit; // 限流阈值
    private final long interval; // 时间窗口（毫秒）
    private final AtomicInteger counter; // 计数器
    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) {
            // 重置计数器
            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); // 模拟请求间隔
        }
    }
}

import java.util.concurrent.atomic.AtomicLong;

public class TokenBucketRateLimiter {
    private final long capacity; // 桶容量
    private final long rate; // 令牌生成速率（令牌/毫秒）
    private final AtomicLong tokens; // 当前令牌数量
    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; // 计算新增令牌数
        if (newTokens > 0) {
            lastRefillTime = now;
            tokens.updateAndGet(old -> Math.min(capacity, old + newTokens)); // 更新令牌数
        }
    }

    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); // 模拟请求间隔
        }
    }
}

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

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); // 模拟请求间隔
        }
    }
}