public class FixedWindowRateLimiter {
    private final int limit; // 限制請求數(shù)量
    private final AtomicInteger count; // 當(dāng)前請求數(shù)
    private final long interval; // 時間間隔（毫秒）
    private long lastRequestTime; // 上一次請求時間
    public FixedWindowRateLimiter(int limit, long interval) {
        this.limit = limit;
        this.interval = interval;
        this.count = new AtomicInteger(0);
        this.lastRequestTime = System.currentTimeMillis();
    }
    public synchronized boolean allowRequest() {
        long currentTime = System.currentTimeMillis();
        if (currentTime - lastRequestTime > interval) {
            // 如果距離上一次請求時間已經(jīng)超過了時間間隔，重置請求數(shù)和上一次請求時間
            count.set(0);
            lastRequestTime = currentTime;
        }
        // 如果請求數(shù)還沒有達到限制數(shù)量，允許請求并增加請求數(shù)
        if (count.get() < limit) {
            count.incrementAndGet();
            return true;
        }
        return false; // 否則拒絕請求
    }
}
// 使用示例
FixedWindowRateLimiter limiter = new FixedWindowRateLimiter(10, 1000); // 每秒最多處理10個請求
for (int i = 0; i < 20; i++) { // 嘗試發(fā)起20個請求
    if (limiter.allowRequest()) {
        System.out.println("Allow request " + i);
    } else {
        System.out.println("Reject request " + i);
    }
    Thread.sleep(200); // 每次請求間隔200毫秒
}

// 窗口存放的實體類（監(jiān)控指標）
public class HystrixEntity {
    // 窗口請求數(shù)
    private AtomicInteger requestCount;
    // 窗口異常數(shù)
    private AtomicInteger errorCount;
    public HystrixEntity(){
        this.requestCount=new AtomicInteger(0);
        this.errorCount=new AtomicInteger(0);
    }
    public int getRequestCountValue() {
        return requestCount.get();
    }
    public int getErrorCountValue() {
        return errorCount.get();
    }
    public void resetValue() {
        this.errorCount.set(0);
        this.requestCount.set(0);
    }
    public void addErrorCount(){
        this.errorCount.addAndGet(1);
    }
    public void addRequestCount(){
        this.requestCount.addAndGet(1);
    }
}
//窗口的定義 HystrixWindow
public class HystrixWindow {
    // 窗口的長度 單位：ms
    private final int windowLengthInMs;
    // 窗口的開始時間戳  單位：ms
    private long windowStartInMs;
    // 窗口內(nèi)存放的實體類
    private HystrixEntity hystrixEntity;
    public HystrixWindow(int windowLengthInMs, long windowStartInMs, HystrixEntity hystrixEntity) {
        this.windowLengthInMs = windowLengthInMs;
        this.windowStartInMs = windowStartInMs;
        this.hystrixEntity = hystrixEntity;
    }
    public int getWindowLengthInMs() {
        return windowLengthInMs;
    }
    public long getWindowStartInMs() {
        return windowStartInMs;
    }
    public HystrixEntity getHystrixEntity() {
        return hystrixEntity;
    }
    public void setHystrixEntity(HystrixEntity hystrixEntity) {
        this.hystrixEntity = hystrixEntity;
    }
    /**
     * @Description 重置窗口
     **/
    public HystrixWindow resetTo(long startTime) {
        this.windowStartInMs = startTime;
        hystrixEntity.resetValue();
        return this;
    }
    /**
     * @Description 判斷時間是否屬于該窗口
     **/
    public boolean isTimeInWindow(long timeMillis) {
        return windowStartInMs <= timeMillis && timeMillis < windowStartInMs + windowLengthInMs;
    }
}
//滑動窗口具體實現(xiàn)
public class HystrixWindowArray {
    // 單個窗口的長度
    private int windowLengthInMs;
    // 窗口數(shù)量
    private int sampleCount;
    // 所有窗口的總長度
    private int intervalInMs;
    // 窗口數(shù)組
    private final AtomicReferenceArray<HystrixWindow> array;
    /**
     * The conditional (predicate) update lock is used only when current bucket is deprecated.
     */
    private final ReentrantLock updateLock = new ReentrantLock();
    /**
     * @Param [sampleCount, intervalInMs]
     * sampleCount: 窗口數(shù)量  intervalInMs：所有窗口的總長度
     **/
    public HystrixWindowArray(int sampleCount, int intervalInMs) {
        Assert.isTrue(sampleCount > 0, "bucket count is invalid: " + sampleCount);
        Assert.isTrue(intervalInMs > 0, "total time interval of the sliding window should be positive");
        Assert.isTrue(intervalInMs % sampleCount == 0, "time span needs to be evenly divided");
        this.windowLengthInMs = intervalInMs / sampleCount;
        this.intervalInMs = intervalInMs;
        this.sampleCount = sampleCount;
        this.array = new AtomicReferenceArray<>(sampleCount);
    }
    /**
     * 獲取當(dāng)前時間所在的窗口下標索引
     */
    private int calculateTimeIdx(long timeMillis) {
        long timeId = timeMillis / windowLengthInMs;
        // Calculate current index so we can map the timestamp to the leap array.
        return (int)(timeId % array.length());
    }
    /**
     * 獲取當(dāng)前時間所在的窗口開始時間
     */
    private long calculateWindowStart(long timeMillis) {
        return timeMillis - timeMillis % windowLengthInMs;
    }
    private HystrixEntity newEmptyWindowValue(long timeMillis){
        return new HystrixEntity();
    }
    /**
     * 獲取當(dāng)前窗口
     */
    public HystrixWindow currentWindow() {
        return currentWindow(System.currentTimeMillis());
    }
    private HystrixWindow currentWindow(long timeMillis) {
        if (timeMillis < 0) {
            return null;
        }
        int idx = calculateTimeIdx(timeMillis);
        // Calculate current bucket start time.
        long windowStart = calculateWindowStart(timeMillis);
        while (true) {
            HystrixWindow old = array.get(idx);
            if (old == null) {
                // 如果獲取為空，說明窗口還沒創(chuàng)建，所以我們創(chuàng)建一個新的窗口(CAS保證線程安全)
                HystrixWindow window = new HystrixWindow(windowLengthInMs, windowStart, newEmptyWindowValue(timeMillis));
                if (array.compareAndSet(idx, null, window)) {
                    // 創(chuàng)建成功則返回當(dāng)前窗口
                    return window;
                } else {
                    // 創(chuàng)建失敗說明發(fā)生了競爭，所以暫時先讓出CPU
                    Thread.yield();
                }
            } else if (windowStart == old.getWindowStartInMs()) {
                // 如果窗口已經(jīng)存在，則對比窗口的開始時間是否相同，相同說明是用同一個窗口，直接返回窗口就可以了
                return old;
            } else if (windowStart > old.getWindowStartInMs()) {
                // 如果窗口已經(jīng)存在，而且窗口開始時間比之前的窗口開始時間要大
                // 說明原來的窗口已經(jīng)過時了，需要替換一個新的窗口
                // 所以加鎖防止競爭
                if (updateLock.tryLock()) {
                    try {
                        // 這里我選擇直接重置之前的窗口（）
                        return resetWindowTo(old, windowStart);
                    } finally {
                        updateLock.unlock();
                    }
                } else {
                    // Contention failed, the thread will yield its time slice to wait for bucket available.
                    Thread.yield();
                }
            } else if (windowStart < old.getWindowStartInMs()) {
                // 窗口的開始時間比之前的窗口開始時間還會小，這種屬于異常情況
                // 要是真出現(xiàn)了也只能新建一個窗口返回了
                return new HystrixWindow(windowLengthInMs, windowStart, newEmptyWindowValue(timeMillis));
            }
        }
    }
    /**
     * 獲取當(dāng)前窗口內(nèi)的值
     */
    public HystrixEntity getWindowValue() {
        return getWindowValue(System.currentTimeMillis());
    }
    public HystrixEntity getWindowValue(long timeMillis) {
        if (timeMillis < 0) {
            return null;
        }
        int idx = calculateTimeIdx(timeMillis);
        HystrixWindow bucket = array.get(idx);
        if (bucket == null || !bucket.isTimeInWindow(timeMillis)) {
            return null;
        }
        return bucket.getHystrixEntity();
    }
    /**
     * 重置一個窗口
     */
    private HystrixWindow resetWindowTo(HystrixWindow window, long startTime){
        return window.resetTo(startTime);
    }
    public List<HystrixEntity> values() {
        return values(System.currentTimeMillis());
    }
    private List<HystrixEntity> values(long timeMillis) {
        if (timeMillis < 0) {
            return new ArrayList<HystrixEntity>();
        }
        int size = array.length();
        List<HystrixEntity> result = new ArrayList<HystrixEntity>(size);
        for (int i = 0; i < size; i++) {
            HystrixWindow window = array.get(i);
            if (window == null || isWindowDeprecated(timeMillis, window)) {
                continue;
            }
            result.add(window.getHystrixEntity());
        }
        return result;
    }
    /**
     * 判斷窗口是否有效
     */
    public boolean isWindowDeprecated(long time, HystrixWindow window) {
        return time - window.getWindowStartInMs() > intervalInMs;
    }
}

// 初始化 代表監(jiān)控1s內(nèi)的指標  窗口數(shù)為2
HystrixWindowArray hystrixWindowArray = new HystrixWindowArray(2, 1000);
// 指標監(jiān)控  數(shù)量+1 
windowArray.currentWindow().getHystrixEntity().addErrorCount();
windowArray.currentWindow().getHystrixEntity().addRequestCount();
// 獲取所有窗口的指標累計  判斷是否超標,也就是1s內(nèi)的總計
List<HystrixEntity> windowValues = windowArray.values();
Integer errorCount = hystrixEntities.stream().map(HystrixEntity::getErrorCountValue).reduce(Integer::sum).get();
Integer requestCount = hystrixEntities.stream().map(HystrixEntity::getRequestCountValue).reduce(Integer::sum).get();

public class TokenBucket {
    private long lastTime;  // 上次請求時間
    private double rate;    // 令牌放入速率
    private long capacity;  // 令牌桶容量
    private long tokens;    // 當(dāng)前令牌數(shù)量
    public TokenBucket(double rate, long capacity) {
        this.lastTime = System.currentTimeMillis();
        this.rate = rate;
        this.capacity = capacity;
        this.tokens = capacity;
    }
    public synchronized boolean getToken() {
        long now = System.currentTimeMillis();
        long timeElapsed = now - lastTime;
        tokens += timeElapsed * rate;
        if (tokens > capacity) {
            tokens = capacity;
        }
        lastTime = now;
        if (tokens >= 1) {
            tokens--;
            return true;
        } else {
            return false;
        }
    }
}

public class LeakyBucket {
    private int capacity; //漏桶容量
    private int rate; //漏水速率
    private int water; //當(dāng)前水量
    private Instant timestamp; //上次漏水時間
    public LeakyBucket(int capacity, int rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.water = 0;
        this.timestamp = Instant.now();
    }
    public synchronized boolean allow() { //判斷是否允許通過
        Instant now = Instant.now();
        long duration = now.toEpochMilli() - timestamp.toEpochMilli(); //計算距上次漏水過去了多久
        int outflow = (int) (duration * rate / 1000); //計算過去的時間內(nèi)漏出的水量
        water = Math.max(0, water - outflow); //更新當(dāng)前水量，不能小于0
        if (water < capacity) { //如果漏桶還沒滿，放行
            water++;
            timestamp = now;
            return true;
        }
        return false; //否則拒絕通過
    }
}