public class FixedWindowRateLimiter {
    private final int requestLimit; // 限流閾值
    private final long windowSize; // 時(shí)間窗口大?。ê撩耄?
    private int count; // 計(jì)數(shù)器
    private volatile long windowStart; // 時(shí)間窗口起始時(shí)間

    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)前時(shí)間已經(jīng)超出窗口時(shí)間，則重置窗口
            windowStart = currentTime;
            count = 0;
        }
        if (count < requestLimit) {
            count++; // 增加計(jì)數(shù)
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) {
        FixedWindowRateLimiter fixedWindowRateLimiter = new FixedWindowRateLimiter(10, 2); // 時(shí)間窗口大小，請(qǐng)求閾值（請(qǐng)求限制）
        for (int i = 0;i < 10;i++) {
            boolean allowed = fixedWindowRateLimiter.tryAcquire();
            System.out.println("請(qǐng)求" + (i+1) + "：" + (allowed ? "被允許" : "被拒絕"));
        }
    }
}

public class SlidingWindowRateLimiter {
    private final int windowSize;  // 時(shí)間窗口大小，單位為秒
    private final int requestLimit;  // 在時(shí)間窗口內(nèi)允許的最大請(qǐng)求數(shù)
    private final LinkedList<Long> timestamps;  // 存儲(chǔ)請(qǐng)求的時(shí)間戳

    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)前時(shí)間戳（秒）

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

        // 檢查當(dāng)前請(qǐng)求數(shù)是否超過限制
        if (timestamps.size() < requestLimit) {
            timestamps.addLast(currentTime);
            return true;  // 允許請(qǐng)求
        } else {
            return false;  // 請(qǐng)求超過限制
        }
    }

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

        // 模擬請(qǐng)求
        for (int i = 0; i < 10; i++) {
            boolean allowed = rateLimiter.allowRequest();
            System.out.println("請(qǐng)求 " + (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; // 漏水速率，單位：請(qǐng)求/秒
    private AtomicLong water; // 當(dāng)前桶中的水量
    private Instant lastLeakTime; // 上一次漏水的時(shí)間點(diǎn)

    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; // 桶未滿，允許請(qǐng)求通過
        } else {
            return false; // 桶已滿，拒絕請(qǐng)求
        }
    }

    private synchronized void leak() {
        Instant now = Instant.now();
        long interval = now.getEpochSecond() - lastLeakTime.getEpochSecond();
        long leakedWater = interval * rate; // 計(jì)算漏水的數(shù)量
        if (leakedWater > 0) {
            water.set(Math.max(0, water.get() - leakedWater)); // 更新桶中的水量
            lastLeakTime = now; // 更新上一次漏水的時(shí)間點(diǎn)
        }
    }

    public static void main(String[] args) {
        LeakyBucketRateLimiter leakyBucketRateLimiter = new LeakyBucketRateLimiter(5, 2); // 創(chuàng)建一個(gè)容量為10，速率為1個(gè)請(qǐng)求/秒的漏桶
        for (int i = 0; i < 10; i++) {
            boolean allowed = leakyBucketRateLimiter.allowed();
            System.out.println("請(qǐng)求 " + (i + 1) + ": " + (allowed ? "被允許" : "被拒絕"));
            try {
                Thread.sleep(100); // 模擬請(qǐng)求間隔
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

@Service
public class RedisLimiterManager {

    @Resource
    private RedissonClient redissonClient;

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