最常用的限流器，一文讲透

📐 原理

将时间轴划分为固定大小的窗口（如 1 秒 / 1 分钟）。每个窗口起始时计数器归零，每来一个请求计数器 +1；当计数器 ≥ 阈值时，后续请求被拒绝，直到进入下一个窗口重新计数。实现最简单、内存占用最低，但存在窗口边界突刺问题。

💻 实现代码（Java，线程安全）

public class FixedWindowRateLimiter {
    private final int limit;          // 窗口内允许的最大请求数
    private final long windowSizeMs;  // 窗口大小（毫秒）
    private int counter;              // 当前窗口计数器
    private long windowStart;         // 当前窗口起始时间戳

    public FixedWindowRateLimiter(int limit, long windowSizeMs) {
        this.limit = limit;
        this.windowSizeMs = windowSizeMs;
        this.windowStart = System.currentTimeMillis();
        this.counter = 0;
    }

    /** 尝试获取一个配额，成功返回 true */
    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        // 1. 若已跨入新窗口，则重置计数器与窗口起点
        if (now - windowStart >= windowSizeMs) {
            windowStart = now;
            counter = 0;
        }
        // 2. 未超阈值则放行并计数
        if (counter < limit) {
            counter++;
            return true;
        }
        // 3. 超过阈值，拒绝
        return false;
    }
}

📐 原理

固定窗口的问题是边界突变。滑动窗口把一个大窗口（如 60 秒）细分为 N 个小桶（如 60 个 1 秒桶），只保留最近 N 个桶的计数总和。随着时间推进，窗口像「滑块」一样平滑移动，从而消除边界突刺。它是精度与成本的折中：桶越多越精确，内存略增。

💻 实现代码（Java，滚动桶）

public class SlidingWindowRateLimiter {
    private final int limit;          // 窗口内最大请求数
    private final long windowMs;      // 总窗口大小（毫秒）
    private final int bucketCount;    // 小桶数量
    private final long bucketMs;      // 每个小桶的时间跨度
    private final int[] buckets;      // 各桶计数
    private int idx;                  // 当前写入桶下标
    private long windowStart;         // 当前窗口起点
    private int total;                // 窗口内总计数（缓存）

    public SlidingWindowRateLimiter(int limit, long windowMs, int bucketCount) {
        this.limit = limit;
        this.windowMs = windowMs;
        this.bucketCount = bucketCount;
        this.bucketMs = windowMs / bucketCount;
        this.buckets = new int[bucketCount];
        this.windowStart = System.currentTimeMillis();
        this.idx = 0; this.total = 0;
    }

    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        long elapsed = now - windowStart;
        // 1. 推进窗口：把过期的桶清零并从 total 扣除
        while (elapsed >= bucketMs) {
            idx = (idx + 1) % bucketCount;
            total -= buckets[idx];
            buckets[idx] = 0;
            windowStart += bucketMs;
            elapsed -= bucketMs;
        }
        // 2. 窗口内未满则放行并计数
        if (total < limit) {
            buckets[idx]++;
            total++;
            return true;
        }
        return false;  // 超限拒绝
    }
}

📐 原理

每来一个请求，就把当前时间戳追加进一个有序集合（队列 / 跳表 / Redis ZSet）。判断时，先删除所有早于 now - window 的过期日志，再看剩余条数是否超过阈值。由于始终基于「真实时间戳」统计，不存在窗口边界误差，精度 100%。代价是：每个请求都要存一条日志，高 QPS 下内存和时间开销显著。

💻 实现代码（Java，基于 Queue）

public class SlidingLogRateLimiter {
    private final int limit;          // 窗口内最大请求数
    private final long windowMs;      // 窗口大小（毫秒）
    private final Queue<Long> logs = new LinkedList<>();

    public SlidingLogRateLimiter(int limit, long windowMs) {
        this.limit = limit;
        this.windowMs = windowMs;
    }

    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        // 1. 移除窗口外的过期时间戳
        while (!logs.isEmpty() && now - logs.peek() >= windowMs) {
            logs.poll();
        }
        // 2. 窗口内未满则记录并放行
        if (logs.size() < limit) {
            logs.offer(now);
            return true;
        }
        return false;  // 超限拒绝
    }
}

📐 原理

有一个容量为 capacity 的桶，以 refillRate（个/秒）的恒定速率生成令牌（不超过容量）。每个请求来时尝试拿走 1 个令牌：有就放行，没有就拒绝（或排队）。当流量低时令牌会积攒，一旦突发流量到来，桶里积攒的令牌允许瞬间处理一波突发，随后速率被限制回 refillRate。Guava RateLimiter、Sentinel 都基于此思想。

💻 实现代码（Java，支持预热/突发）

public class TokenBucketRateLimiter {
    private final long capacity;       // 桶容量（最大突发令牌数）
    private final double refillRate;   // 补充速率（个/秒）
    private double tokens;             // 当前令牌数
    private long lastRefill;           // 上次补充时间

    public TokenBucketRateLimiter(long capacity, double refillRate) {
        this.capacity = capacity;
        this.refillRate = refillRate;
        this.tokens = capacity;        // 初始充满，允许启动突发
        this.lastRefill = System.currentTimeMillis();
    }

    public synchronized boolean tryAcquire(int n) {
        refill();                      // 先按时间补充令牌
        if (tokens >= n) {
            tokens -= n;               // 取走 n 个令牌
            return true;
        }
        return false;                  // 令牌不足，拒绝
    }

    private void refill() {
        long now = System.currentTimeMillis();
        double elapsedSec = (now - lastRefill) / 1000.0;
        tokens = Math.min(capacity, tokens + elapsedSec * refillRate);
        lastRefill = now;
    }
}

📐 原理

把请求看作流入桶里的水，桶底有个小孔以恒定速率 leakRate 漏出（即被处理）。若请求流入速度超过漏出速度，水（请求）会在桶里堆积；当水位超过桶容量 capacity 时，多余的请求被直接拒绝。与令牌桶相反：漏桶「削峰填谷」、强制恒定输出，不提供突发能力，因此能更好地保护下游。

💻 实现代码（Java，漏桶计量版）

public class LeakyBucketRateLimiter {
    private final int capacity;        // 桶容量（最大排队请求数）
    private final double leakRate;     // 漏出速率（个/秒）
    private double water;              // 当前水量（积压请求数）
    private long lastLeak;             // 上次漏水时间

    public LeakyBucketRateLimiter(int capacity, double leakRate) {
        this.capacity = capacity;
        this.leakRate = leakRate;
        this.water = 0;
        this.lastLeak = System.currentTimeMillis();
    }

    public synchronized boolean tryAcquire(int n) {
        leak();                        // 先按时间漏水
        if (water + n <= capacity) {   // 加水后不超过容量则放行
            water += n;
            return true;
        }
        return false;                  // 桶满，拒绝
    }

    private void leak() {
        long now = System.currentTimeMillis();
        double elapsedSec = (now - lastLeak) / 1000.0;
        water = Math.max(0, water - elapsedSec * leakRate);
        lastLeak = now;
    }
}

📐 原理

多台应用实例共享一个 Redis。把计数器 / 时间戳存到 Redis，用 Lua 脚本保证「读-判断-写」的原子性（避免多实例并发导致的超发）。根据算法不同，可用 INCR + EXPIRE（固定窗口）或 ZSet（滑动日志 / 滑动窗口）。

💻 实现代码 A：固定窗口分布式（INCR + Lua）

-- KEYS[1] = 限流 key    ARGV[1] = 阈值    ARGV[2] = 窗口毫秒
local current = redis.call('GET', KEYS[1])
if current and tonumber(current) >= tonumber(ARGV[1]) then
    return 0              -- 已超阈值，拒绝
end
local new = redis.call('INCR', KEYS[1])
if new == 1 then
    redis.call('PEXPIRE', KEYS[1], ARGV[2])  -- 首请求设置窗口过期
end
return 1                  -- 放行

💻 实现代码 B：滑动日志分布式（ZSet + Lua，最精确）

-- KEYS[1] = 限流 key
-- ARGV[1] = 当前时间戳(ms)  ARGV[2] = 窗口(ms)  ARGV[3] = 阈值
-- 1. 删除窗口外的过期请求
redis.call('ZREMRANGEBYSCORE', KEYS[1], 0, ARGV[1] - ARGV[2])
-- 2. 统计窗口内剩余数量
local count = redis.call('ZCARD', KEYS[1])
if count >= tonumber(ARGV[3]) then
    return 0              -- 超限拒绝
end
-- 3. 记录本次请求（用唯一 member 防覆盖）
redis.call('ZADD', KEYS[1], ARGV[1], ARGV[1] .. '-' .. math.random())
redis.call('PEXPIRE', KEYS[1], ARGV[2])
return 1                  -- 放行