java单机滑动窗口限流器

下面使用 ConcurrentHashMap + ConcurrentLinkedDeque 实现一个滑动窗口限流器，限制在 10 秒内最多 N 次请求（例如 5 次）。这种方案只依赖本地内存，适合单机限流场景。

实现原理

• 为每个用户（或 IP）维护一个 双端队列，存储每次请求的时间戳（毫秒）。

• 每次请求时，先清理队列中 超过 10 秒 的旧时间戳，再判断队列大小是否小于阈值：

  • 若小于，则添加当前时间戳，返回 允许；
  • 否则，返回 限流。

• 使用 ConcurrentHashMap 保证对用户 Key 的线程安全，使用 synchronized 对每个队列做同步，避免并发修改。

代码实现

java

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.TimeUnit;

/**
 * 基于 Map 的滑动窗口限流器（10秒限频）
 */
public class LocalSlidingWindowRateLimiter {
    // 存储每个用户的请求时间戳队列
    private final Map<String, ConcurrentLinkedDeque<Long>> userQueueMap = new ConcurrentHashMap<>();
    private final int windowSeconds;   // 窗口大小（秒）
    private final int maxRequests;     // 窗口内最大请求数

    public LocalSlidingWindowRateLimiter(int windowSeconds, int maxRequests) {
        this.windowSeconds = windowSeconds;
        this.maxRequests = maxRequests;
    }

    /**
     * 检查是否允许请求
     * @param key 限流标识（如 userId、ip）
     * @return true 允许，false 被限流
     */
    public boolean allowRequest(String key) {
        long now = System.currentTimeMillis();
        long windowStart = now - TimeUnit.SECONDS.toMillis(windowSeconds);

        // 获取或创建该用户的队列
        ConcurrentLinkedDeque<Long> deque = userQueueMap.computeIfAbsent(key,
                k -> new ConcurrentLinkedDeque<>());

        // 对队列加锁，保证清理和添加的原子性
        synchronized (deque) {
            // 1. 清理过期记录（窗口外的旧时间戳）
            while (!deque.isEmpty() && deque.peekFirst() < windowStart) {
                deque.pollFirst();
            }

            // 2. 判断是否超过阈值
            if (deque.size() < maxRequests) {
                // 允许请求，记录当前时间戳
                deque.addLast(now);
                return true;
            } else {
                return false;
            }
        }
    }

    // 可选：定期清理无数据的用户 Key，避免内存泄漏（可以用 ScheduledExecutorService 定时清理）
    public void cleanEmptyKeys() {
        userQueueMap.entrySet().removeIf(entry -> entry.getValue().isEmpty());
    }
}

使用示例

java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 限流规则：10秒内最多5次请求
        LocalSlidingWindowRateLimiter limiter = new LocalSlidingWindowRateLimiter(10, 5);
        String userId = "user_123";

        for (int i = 0; i < 10; i++) {
            boolean allowed = limiter.allowRequest(userId);
            System.out.println("请求 " + (i + 1) + "：" + (allowed ? "通过" : "限流"));
            Thread.sleep(1000); // 模拟间隔 1 秒
        }
    }
}

输出示例（第 6 次请求被限流，因为 10 秒内已有 5 次）：

text

请求 1：通过
请求 2：通过
请求 3：通过
请求 4：通过
请求 5：通过
请求 6：限流
请求 7：限流
...

注意事项

1. 内存清理：长期不活动的用户 Key 会残留队列对象，建议定时调用 cleanEmptyKeys() 清理。
2. 并发安全：每个队列使用 synchronized 锁保证原子操作，锁粒度小，性能较高。
3. 时间精度：使用毫秒级时间戳，滑动窗口边界判断精确。
4. 适用场景：单机应用、对分布式一致性要求不高的限流场景。