public static Integer counter = 0;  //統計請求數
   public static long lastAcquireTime =  0L;
   public static final Long windowUnit = 1000L ; //假設固定時間窗口是1000ms
   public static final Integer threshold = 10; // 窗口閥值是10
   
    /**
     * 固定窗口時間算法
     * 關注公眾號：撿田螺的小男孩
     * @return
     */
    public synchronized boolean fixedWindowsTryAcquire() {
        long currentTime = System.currentTimeMillis();  //獲取系統當前時間
        if (currentTime - lastAcquireTime > windowUnit) {  //檢查是否在時間窗口內
            counter = 0;  // 計數器清0
            lastAcquireTime = currentTime;  //開啟新的時間窗口
        }
        if (counter < threshold) {  // 小于閥值
            counter++;  //計數統計器加1
            return true;
        }

        return false;
    }

/**
     * 單位時間劃分的小周期（單位時間是1分鐘，10s一個小格子窗口，一共6個格子）
     */
    private int SUB_CYCLE = 10;

    /**
     * 每分鐘限流請求數
     */
    private int thresholdPerMin = 100;

    /**
     * 計數器, k-為當前窗口的開始時間值秒，value為當前窗口的計數
     */
    private final TreeMap<Long, Integer> counters = new TreeMap<>();

   /**
     * 滑動窗口時間算法實現
     */
     public synchronized boolean slidingWindowsTryAcquire() {
        long currentWindowTime = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC) / SUB_CYCLE * SUB_CYCLE; //獲取當前時間在哪個小周期窗口
        int currentWindowNum = countCurrentWindow(currentWindowTime); //當前窗口總請求數

        //超過閥值限流
        if (currentWindowNum >= thresholdPerMin) {
            return false;
        }

        //計數器+1
        counters.get(currentWindowTime)++;
        return true;
    }

   /**
    * 統計當前窗口的請求數
    */
    private int countCurrentWindow(long currentWindowTime) {
        //計算窗口開始位置
        long startTime = currentWindowTime - SUB_CYCLE* (60s/SUB_CYCLE-1);
        int count = 0;

        //遍歷存儲的計數器
        Iterator<Map.Entry<Long, Integer>> iterator = counters.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Long, Integer> entry = iterator.next();
            // 刪除無效過期的子窗口計數器
            if (entry.getKey() < startTime) {
                iterator.remove();
            } else {
                //累加當前窗口的所有計數器之和
                count =count + entry.getValue();
            }
        }
        return count;
    }

/**
 * LeakyBucket 類表示一個漏桶,
 * 包含了桶的容量和漏桶出水速率等參數，
 * 以及當前桶中的水量和上次漏水時間戳等狀態。
 */
public class LeakyBucket {
    private final long capacity;    // 桶的容量
    private final long rate;        // 漏桶出水速率
    private long water;             // 當前桶中的水量
    private long lastLeakTimestamp; // 上次漏水時間戳

    public LeakyBucket(long capacity, long rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.water = 0;
        this.lastLeakTimestamp = System.currentTimeMillis();
    }

    /**
     * tryConsume() 方法用于嘗試向桶中放入一定量的水，如果桶中還有足夠的空間，則返回 true，否則返回 false。
     * @param waterRequested
     * @return
     */
    public synchronized boolean tryConsume(long waterRequested) {
        leak();
        if (water + waterRequested <= capacity) {
            water += waterRequested;
            return true;
        } else {
            return false;
        }
    }

    /**
     * 。leak() 方法用于漏水，根據當前時間和上次漏水時間戳計算出應該漏出的水量，然后更新桶中的水量和漏水時間戳等狀態。
     */
    private void leak() {
        long now = System.currentTimeMillis();
        long elapsedTime = now - lastLeakTimestamp;
        long leakedWater = elapsedTime * rate / 1000;
        if (leakedWater > 0) {
            water = Math.max(0, water - leakedWater);
            lastLeakTimestamp = now;
        }
    }
}

/**
 * TokenBucket 類表示一個令牌桶
 */
public class TokenBucket {

    private final int capacity;     // 令牌桶容量
    private final int rate;         // 令牌生成速率，單位：令牌/秒
    private int tokens;             // 當前令牌數量
    private long lastRefillTimestamp;  // 上次令牌生成時間戳

    /**
     * 構造函數中傳入令牌桶的容量和令牌生成速率。
     * @param capacity
     * @param rate
     */
    public TokenBucket(int capacity, int rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.tokens = capacity;
        this.lastRefillTimestamp = System.currentTimeMillis();
    }

    /**
     * allowRequest() 方法表示一個請求是否允許通過，該方法使用 synchronized 關鍵字進行同步，以保證線程安全。
     * @return
     */
    public synchronized boolean allowRequest() {
        refill();
        if (tokens > 0) {
            tokens--;
            return true;
        } else {
            return false;
        }
    }

    /**
     * refill() 方法用于生成令牌，其中計算令牌數量的邏輯是按照令牌生成速率每秒鐘生成一定數量的令牌，
     * tokens 變量表示當前令牌數量，
     * lastRefillTimestamp 變量表示上次令牌生成的時間戳。
     */
    private void refill() {
        long now = System.currentTimeMillis();
        if (now > lastRefillTimestamp) {
            int generatedTokens = (int) ((now - lastRefillTimestamp) / 1000 * rate);
            tokens = Math.min(tokens + generatedTokens, capacity);
            lastRefillTimestamp = now;
        }
    }
}