public class LeakyBucket {
    private int capacity; // 버킷의 최대 크기 (허용 가능한 최대 요청 수)
    private long lastDripTime; // 마지막으로 물이 새어나간(처리된) 시각
    private int water; // 현재 버킷에 쌓인 물의 양 (현재 처리 대기 중인 요청 수)
    private int dripRate; // 초당 물이 새어나가는 속도 (요청 처리 속도)
 
    /**
     * LeakyBucket 생성자
     * @param capacity 버킷의 최대 크기
     * @param dripRate 초당 처리할 수 있는 요청의 수
     */
    public LeakyBucket(int capacity, int dripRate) {
        this.capacity = capacity; // 버킷의 최대 크기 설정
        this.dripRate = dripRate; // 초당 처리 속도 설정
        this.lastDripTime = System.currentTimeMillis(); // 객체 생성 시점의 시간을 기록
        this.water = 0; // 초기 버킷은 비어 있음
    }
 
    /**
     * 요청이 허용 가능한지 확인
     * @return 요청이 허용되면 true, 그렇지 않으면 false 반환
     */
    public synchronized boolean allowRequest() {
        long currentTime = System.currentTimeMillis(); // 현재 시각 기록
        long elapsed = currentTime - lastDripTime; // 마지막 처리 이후 경과 시간 계산
        // 경과 시간에 따라 새어나간 물의 양 계산
        // (예: 초당 5 요청 처리 가능하면, 2초 경과 시 10 요청 처리)
        int leaked = (int) (elapsed * dripRate / 1000); 
 
        // 경과 시간 동안 새어나간 물을 반영하여 현재 물 양 갱신
        // 버킷의 물은 0 이하로 내려갈 수 없으므로 Math.max로 보호
        water = Math.max(0, water - leaked); 
 
        // 마지막 물 새어나간 시각을 현재 시각으로 갱신
        lastDripTime = currentTime; 
 
        if (water < capacity) { 
            // 현재 버킷의 물 양이 최대 크기보다 작다면 요청을 허용
            water++; // 새 요청을 처리하기 위해 버킷에 물을 추가
            return true; // 요청 허용
        } else {
            return false; // 요청 거부 (버킷이 가득 찼기 때문)
        }
    }
}

public class TokenBucket {
    private int capacity; // Bucket capacity
    private int tokens; // Current token count
    private long lastRefillTime;
    private int refillRate; // Tokens added per second
 
    public TokenBucket(int capacity, int refillRate) {
        this.capacity = capacity;
        this.refillRate = refillRate;
        this.tokens = capacity;
        this.lastRefillTime = System.currentTimeMillis();
    }
 
    public synchronized boolean allowRequest() {
        refill();
        if (tokens > 0) {
            tokens--;
            return true;
        }
        return false; // Request denied
    }
 
    private void refill() {
        long currentTime = System.currentTimeMillis();
        long elapsed = currentTime - lastRefillTime;
        int refillTokens = (int) (elapsed * refillRate / 1000);
        if (refillTokens > 0) {
            tokens = Math.min(capacity, tokens + refillTokens);
            lastRefillTime = currentTime;
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;
 
public class FixedWindow {
    private int maxRequests;
    private long windowStart;
    private long windowDuration;
    private AtomicInteger requestCount;
 
    public FixedWindow(int maxRequests, long windowDurationMillis) {
        this.maxRequests = maxRequests;
        this.windowDuration = windowDurationMillis;
        this.windowStart = System.currentTimeMillis();
        this.requestCount = new AtomicInteger(0);
    }
 
    public synchronized boolean allowRequest() {
        long currentTime = System.currentTimeMillis();
        if (currentTime - windowStart >= windowDuration) {
            windowStart = currentTime;
            requestCount.set(0);
        }
 
        if (requestCount.incrementAndGet() <= maxRequests) {
            return true;
        } else {
            return false; // Request denied
        }
    }
}

import java.util.LinkedList;
 
public class SlidingWindowLog {
    private int maxRequests;
    private long windowDuration;
    private LinkedList<Long> requestTimestamps;
 
    public SlidingWindowLog(int maxRequests, long windowDurationMillis) {
        this.maxRequests = maxRequests;
        this.windowDuration = windowDurationMillis;
        this.requestTimestamps = new LinkedList<>();
    }
 
    public synchronized boolean allowRequest() {
        long currentTime = System.currentTimeMillis();
        while (!requestTimestamps.isEmpty() && 
               currentTime - requestTimestamps.peek() >= windowDuration) {
            requestTimestamps.poll();
        }
 
        if (requestTimestamps.size() < maxRequests) {
            requestTimestamps.add(currentTime);
            return true;
        }
        return false; // Request denied
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
 
public class SlidingWindowCounter {
    private int maxRequests; // 최대 허용 요청 수
    private long windowDuration; // 슬라이딩 윈도우의 전체 기간 (밀리초 단위)
    private int splitParts; // 윈도우를 나눌 부분 수 (슬롯의 개수)
    private ConcurrentMap<Long, Integer> counters; // 각 슬롯(windowKey)별 요청 수를 저장하는 맵
 
    // 생성자: 윈도우 크기, 최대 요청 수, 나눌 부분 수 초기화
    public SlidingWindowCounter(int maxRequests, long windowDurationMillis, int splitParts) {
        this.maxRequests = maxRequests; // 최대 허용 요청 수 설정
        this.windowDuration = windowDurationMillis; // 윈도우 지속 시간 설정
        this.splitParts = splitParts; // 윈도우를 나눌 슬롯의 개수 설정
        this.counters = new ConcurrentHashMap<>(); 
    }
 
    // 요청이 허용 가능한지 확인
    public boolean allowRequest() {
        long currentTime = System.currentTimeMillis(); // 현재 시간 (밀리초 단위)
        long windowKey = currentTime / (windowDuration / splitParts); 
        // 현재 시간 기준으로 요청이 속한 윈도우 키 계산
 
        // 현재 윈도우 슬롯의 요청 수 증가 (스레드 안전)
        counters.merge(windowKey, 1, Integer::sum);
 
        // 만료된 윈도우 슬롯 제거
        counters.keySet().removeIf(key -> key < windowKey - splitParts);
 
        // 전체 요청 수 합산
        int totalCount = counters.values().stream().mapToInt(Integer::intValue).sum();
 
        // 총 요청 수가 최대 허용 요청 수를 초과하지 않으면 요청 허용
        return totalCount <= maxRequests;
    }
}