Java代码实现四种限流算法详细介绍

public class FixedWindowRateLimiter {
    private final int requestLimit; // 限流阈值
    private final long windowSize; // 时间窗口大小（毫秒）
    private int count; // 计数器
    private volatile long windowStart; // 时间窗口起始时间

    public FixedWindowRateLimiter(long windowSize, int requestLimit) {
        this.windowSize = windowSize;
        this.requestLimit = requestLimit;
        this.count = 0;
        this.windowStart = System.currentTimeMillis() / 1000;
    }

    public synchronized boolean tryAcquire() {
        long currentTime = System.currentTimeMillis();
        if (currentTime - windowStart > windowSize) { // 如果当前时间已经超出窗口时间，则重置窗口
            windowStart = currentTime;
            count = 0;
        }
        if (count < requestLimit) {
            count++; // 增加计数
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) {
        FixedWindowRateLimiter fixedWindowRateLimiter = new FixedWindowRateLimiter(10, 2); // 时间窗口大小，请求阈值（请求限制）
        for (int i = 0;i < 10;i++) {
            boolean allowed = fixedWindowRateLimiter.tryAcquire();
            System.out.println("请求" + (i+1) + "：" + (allowed ? "被允许" : "被拒绝"));
        }
    }
}

public class SlidingWindowRateLimiter {
    private final int windowSize;  // 时间窗口大小，单位为秒
    private final int requestLimit;  // 在时间窗口内允许的最大请求数
    private final LinkedList<Long> timestamps;  // 存储请求的时间戳

    public SlidingWindowRateLimiter(int windowSize, int requestLimit) {
        this.windowSize = windowSize;
        this.requestLimit = requestLimit;
        this.timestamps = new LinkedList<>();
    }

    public synchronized boolean allowRequest() {
        long currentTime = System.currentTimeMillis() / 1000;  // 获取当前时间戳（秒）

        // 移除时间窗口之外的时间戳
        while (!timestamps.isEmpty() && timestamps.getFirst() <= currentTime - windowSize) {
            timestamps.removeFirst();
        }

        // 检查当前请求数是否超过限制
        if (timestamps.size() < requestLimit) {
            timestamps.addLast(currentTime);
            return true;  // 允许请求
        } else {
            return false;  // 请求超过限制
        }
    }

    public static void main(String[] args) {
        SlidingWindowRateLimiter rateLimiter = new SlidingWindowRateLimiter(10, 2);

        // 模拟请求
        for (int i = 0; i < 10; i++) {
            boolean allowed = rateLimiter.allowRequest();
            System.out.println("请求 " + (i + 1) + ": " + (allowed ? "被允许" : "被拒绝"));
        }
    }
}

package DataStructure.RateLimtAlgorithm;

import java.time.Instant;
import java.util.concurrent.atomic.AtomicLong;

public class LeakyBucketRateLimiter {
    private final int capacity; // 桶的容量
    private final int rate; // 漏水速率，单位：请求/秒
    private AtomicLong water; // 当前桶中的水量
    private Instant lastLeakTime; // 上一次漏水的时间点

    public LeakyBucketRateLimiter(int capacity, int rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.water = new AtomicLong(0);
        this.lastLeakTime = Instant.now();
    }

    public synchronized boolean allowed() {
        leak(); // 漏水
        if (water.get() < capacity) {
            water.incrementAndGet();
            return true; // 桶未满，允许请求通过
        } else {
            return false; // 桶已满，拒绝请求
        }
    }

    private synchronized void leak() {
        Instant now = Instant.now();
        long interval = now.getEpochSecond() - lastLeakTime.getEpochSecond();
        long leakedWater = interval * rate; // 计算漏水的数量
        if (leakedWater > 0) {
            water.set(Math.max(0, water.get() - leakedWater)); // 更新桶中的水量
            lastLeakTime = now; // 更新上一次漏水的时间点
        }
    }

    public static void main(String[] args) {
        LeakyBucketRateLimiter leakyBucketRateLimiter = new LeakyBucketRateLimiter(5, 2); // 创建一个容量为10，速率为1个请求/秒的漏桶
        for (int i = 0; i < 10; i++) {
            boolean allowed = leakyBucketRateLimiter.allowed();
            System.out.println("请求 " + (i + 1) + ": " + (allowed ? "被允许" : "被拒绝"));
            try {
                Thread.sleep(100); // 模拟请求间隔
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

@Service
public class RedisLimiterManager {

    @Resource
    private RedissonClient redissonClient;

    /**
     * 限流操作
     *
     * @param key 区分不同的限流器，比如不同的用户 id 应该分别统计
     */
    public void doRateLimit(String key) {
        // 创建一个名称为user_limiter的限流器，每秒最多访问2次
        RRateLimiter rateLimiter = redissonClient.getRateLimiter(key);
        rateLimiter.trySetRate(RateType.OVERALL, 2, 1, RateIntervalUnit.SECONDS); // OVERALL类型：不管有多少台服务器都是放在一起统计的，请求阈值，生成令牌的频率
        // 每当一个操作来了后，请求一个令牌
        boolean canOp = rateLimiter.tryAcquire(1);// 令牌请求数，处理请求需消耗的令牌
        if (!canOp) {
            throw new BusinessException(ErrorCode.TOO_MANY_REQUEST);
        }
    }
}

@SpringBootTest
class RedisLimiterManagerTest {
    @Resource
    private RedisLimiterManager redisLimiterManager;

    @Test
    void doRateLimit() throws InterruptedException {
        String userId = "1";
        for (int i=0;i<10;i++) {
            redisLimiterManager.doRateLimit(userId);
            System.out.println("success");
        }
    }
}