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

        return false;
    }

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

    /**
     * 每分鐘限流請(qǐng)求數(shù)
     */
    private int thresholdPerMin = 100;

    /**
     * 計(jì)數(shù)器, k-為當(dāng)前窗口的開(kāi)始時(shí)間值秒，value為當(dāng)前窗口的計(jì)數(shù)
     */
    private final TreeMap<Long, Integer> counters = new TreeMap<>();

   /**
     * 滑動(dòng)窗口時(shí)間算法實(shí)現(xiàn)
     */
     public synchronized boolean slidingWindowsTryAcquire() {
        long currentWindowTime = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC) / SUB_CYCLE * SUB_CYCLE; //獲取當(dāng)前時(shí)間在哪個(gè)小周期窗口
        int currentWindowNum = countCurrentWindow(currentWindowTime); //當(dāng)前窗口總請(qǐng)求數(shù)

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

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

   /**
    * 統(tǒng)計(jì)當(dāng)前窗口的請(qǐng)求數(shù)
    */
    private int countCurrentWindow(long currentWindowTime) {
        //計(jì)算窗口開(kāi)始位置
        long startTime = currentWindowTime - SUB_CYCLE* (60s/SUB_CYCLE-1);
        int count = 0;

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

/**
 * LeakyBucket 類(lèi)表示一個(gè)漏桶,
 * 包含了桶的容量和漏桶出水速率等參數(shù)，
 * 以及當(dāng)前桶中的水量和上次漏水時(shí)間戳等狀態(tài)。
 */
public class LeakyBucket {
    private final long capacity;    // 桶的容量
    private final long rate;        // 漏桶出水速率
    private long water;             // 當(dāng)前桶中的水量
    private long lastLeakTimestamp; // 上次漏水時(shí)間戳

    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() 方法用于漏水，根據(jù)當(dāng)前時(shí)間和上次漏水時(shí)間戳計(jì)算出應(yīng)該漏出的水量，然后更新桶中的水量和漏水時(shí)間戳等狀態(tài)。
     */
    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 類(lèi)表示一個(gè)令牌桶
 */
public class TokenBucket {

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

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

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

    /**
     * refill() 方法用于生成令牌，其中計(jì)算令牌數(shù)量的邏輯是按照令牌生成速率每秒鐘生成一定數(shù)量的令牌，
     * tokens 變量表示當(dāng)前令牌數(shù)量，
     * lastRefillTimestamp 變量表示上次令牌生成的時(shí)間戳。
     */
    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;
        }
    }
}