/**
     * 固定窗口時間算法
     * @return
     */
    boolean fixedWindowsTryAcquire() {
        long currentTime = System.currentTimeMillis();  //獲取系統(tǒng)當(dāng)前時間
        if (currentTime - lastRequestTime > windowUnit) {  //檢查是否在時間窗口內(nèi)
            counter = 0;  // 計數(shù)器清0
            lastRequestTime = currentTime;  //開啟新的時間窗口
        }
        if (counter < threshold) {  // 小于閥值
            counter++;  //計數(shù)器加1
            return true;
        }

        return false;
    }

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

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

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

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

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

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

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

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

 /**
     * 每秒處理數(shù)（出水率）
     */
    private long rate;

    /**
     *  當(dāng)前剩余水量
     */
    private long currentWater;

    /**
     * 最后刷新時間
     */
    private long refreshTime;

    /**
     * 桶容量
     */
    private long capacity;

    /**
     * 漏桶算法
     * @return
     */
    boolean leakybucketLimitTryAcquire() {
        long currentTime = System.currentTimeMillis();  //獲取系統(tǒng)當(dāng)前時間
        long outWater = (currentTime - refreshTime) / 1000 * rate; //流出的水量 =(當(dāng)前時間-上次刷新時間)* 出水率
        long currentWater = Math.max(0, currentWater - outWater); // 當(dāng)前水量 = 之前的桶內(nèi)水量-流出的水量
        refreshTime = currentTime; // 刷新時間

        // 當(dāng)前剩余水量還是小于桶的容量，則請求放行
        if (currentWater < capacity) {
            currentWater++;
            return true;
        }
        
        // 當(dāng)前剩余水量大于等于桶的容量，限流
        return false;
    }

    /**
     * 每秒處理數(shù)（放入令牌數(shù)量）
     */
    private long putTokenRate;
    
    /**
     * 最后刷新時間
     */
    private long refreshTime;

    /**
     * 令牌桶容量
     */
    private long capacity;
    
    /**
     * 當(dāng)前桶內(nèi)令牌數(shù)
     */
    private long currentToken = 0L;

    /**
     * 漏桶算法
     * @return
     */
    boolean tokenBucketTryAcquire() {

        long currentTime = System.currentTimeMillis();  //獲取系統(tǒng)當(dāng)前時間
        long generateToken = (currentTime - refreshTime) / 1000 * putTokenRate; //生成的令牌 =(當(dāng)前時間-上次刷新時間)* 放入令牌的速率
        currentToken = Math.min(capacity, generateToken + currentToken); // 當(dāng)前令牌數(shù)量 = 之前的桶內(nèi)令牌數(shù)量+放入的令牌數(shù)量
        refreshTime = currentTime; // 刷新時間
        
        //桶里面還有令牌，請求正常處理
        if (currentToken > 0) {
            currentToken--; //令牌數(shù)量-1
            return true;
        }
        
        return false;
    }