#滑动窗口限流

public class SlidingWindowRateLimiter {

    private final int windowSizeSeconds;  // 窗口大小（秒）
    private final int maxRequests;        // 窗口内最大请求数
    private final AtomicInteger[] counters;  // 每个小窗口的计数器
    private final int bucketCount;         // 小窗口数量
    private volatile long windowStartTime; // 窗口开始时间
    private final AtomicLong position;     // 当前小窗口位置

    public SlidingWindowRateLimiter(int windowSizeSeconds, int maxRequests, int bucketCount) {
        this.windowSizeSeconds = windowSizeSeconds;
        this.maxRequests = maxRequests;
        this.bucketCount = bucketCount;
        this.counters = new AtomicInteger[bucketCount];
        for (int i = 0; i < bucketCount; i++) {
            counters[i] = new AtomicInteger(0);
        }
        this.windowStartTime = System.currentTimeMillis() / 1000 * 1000;
        this.position = new AtomicLong(0);
    }

    public boolean tryAcquire() {
        long now = System.currentTimeMillis();
        long windowStart = now / 1000 * 1000;

        // 检查是否进入新的时间窗口
        if (windowStart > windowStartTime) {
            resetWindow(windowStart);
        }

        // 计算当前请求应该计入哪个桶
        int bucket = (int) (position.get() % bucketCount);

        // 获取当前窗口的总计数
        int total = getTotalCount();

        if (total < maxRequests) {
            counters[bucket].incrementAndGet();
            return true;
        }

        return false;
    }

    private int getTotalCount() {
        int total = 0;
        for (AtomicInteger counter : counters) {
            total += counter.get();
        }
        return total;
    }

    private void resetWindow(long newWindowStart) {
        windowStartTime = newWindowStart;
        position.incrementAndGet();

        // 只清空最老的桶，避免每次都清空所有桶
        int oldBucket = (int) ((position.get() - bucketCount) % bucketCount);
        if (oldBucket >= 0 && oldBucket < bucketCount) {
            counters[oldBucket].set(0);
        }
    }
}

public class PreciseSlidingWindow {

    private final int windowSizeMs;        // 窗口大小（毫秒）
    private final int maxRequests;           // 窗口内最大请求数
    private final Queue<Long> requests;    // 存储请求时间戳

    public PreciseSlidingWindow(int windowSizeMs, int maxRequests) {
        this.windowSizeMs = windowSizeMs;
        this.maxRequests = maxRequests;
        this.requests = new ConcurrentLinkedQueue<>();
    }

    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        long windowStart = now - windowSizeMs;

        // 移除窗口外的请求
        while (!requests.isEmpty() && requests.peek() < windowStart) {
            requests.poll();
        }

        // 检查是否超过限制
        if (requests.size() < maxRequests) {
            requests.offer(now);
            return true;
        }

        return false;
    }

    public int getCurrentCount() {
        long now = System.currentTimeMillis();
        long windowStart = now - windowSizeMs;

        return (int) requests.stream()
            .filter(timestamp -> timestamp >= windowStart)
            .count();
    }
}

public class RedisSlidingWindowLimiter {

    private final RedisTemplate<String, String> redisTemplate;
    private final String luaScript;

    public RedisSlidingWindowLimiter(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.luaScript = loadScript("sliding_window.lua");
    }

    /**
     * 尝试获取令牌
     * @param key 限流 key
     * @param windowSizeMs 窗口大小（毫秒）
     * @param maxRequests 窗口内最大请求数
     * @return 是否成功
     */
    public boolean tryAcquire(String key, int windowSizeMs, int maxRequests) {
        String requestId = UUID.randomUUID().toString();

        Long result = redisTemplate.execute(
            new DefaultRedisScript<>(luaScript, Long.class),
            List.of(key),
            windowSizeMs,
            maxRequests,
            System.currentTimeMillis(),
            requestId
        );
        return result != null && result == 1;
    }

    /**
     * 获取当前窗口内的请求数
     */
    public long getCurrentCount(String key, int windowSizeMs) {
        long now = System.currentTimeMillis();
        long windowStart = now - windowSizeMs;

        // 移除过期数据并计数
        Long removed = redisTemplate.opsForZSet().removeRangeByScore(key, Double.NEGATIVE_INFINITY, windowStart);
        return redisTemplate.opsForZSet().zCard(key);
    }
}