public class FixedWindowRateLimiter {
    private final int requestLimit; // 限流閾值
    private final long windowSize; // 時間窗口大小（毫秒）
    private int count; // 計數(shù)器
    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) { // 如果當(dāng)前時間已經(jīng)超出窗口時間，則重置窗口
            windowStart = currentTime;
            count = 0;
        }
        if (count < requestLimit) {
            count++; // 增加計數(shù)
            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;  // 在時間窗口內(nèi)允許的最大請求數(shù)
    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;  // 獲取當(dāng)前時間戳（秒）

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

        // 檢查當(dāng)前請求數(shù)是否超過限制
        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; // 當(dāng)前桶中的水量
    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; // 計算漏水的數(shù)量
        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); // 創(chuàng)建一個容量為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 區(qū)分不同的限流器，比如不同的用戶 id 應(yīng)該分別統(tǒng)計
     */
    public void doRateLimit(String key) {
        // 創(chuàng)建一個名稱為user_limiter的限流器，每秒最多訪問2次
        RRateLimiter rateLimiter = redissonClient.getRateLimiter(key);
        rateLimiter.trySetRate(RateType.OVERALL, 2, 1, RateIntervalUnit.SECONDS); // OVERALL類型：不管有多少臺服務(wù)器都是放在一起統(tǒng)計的，請求閾值，生成令牌的頻率
        // 每當(dāng)一個操作來了后，請求一個令牌
        boolean canOp = rateLimiter.tryAcquire(1);// 令牌請求數(shù)，處理請求需消耗的令牌
        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");
        }
    }
}