import java.util.concurrent.*;
import java.time.Instant;

public class RateLimiting {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> requests = new LinkedBlockingQueue<>();
        for (int i = 1; i <= 5; i++) {
            requests.offer(i);
        }

        // This ScheduledExecutorService will execute a task every 200 milliseconds.
        // This is the regulator in our rate limiting scheme.
        ScheduledExecutorService limiter = Executors.newScheduledThreadPool(1);
        ScheduledFuture<?> limiterHandle = limiter.scheduleAtFixedRate(() -> {
            try {
                Integer req = requests.take();
                System.out.println("request " + req + " " + Instant.now());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 0, 200, TimeUnit.MILLISECONDS);

        // Wait for all requests to be processed
        while (!requests.isEmpty()) {
            Thread.sleep(100);
        }

        limiterHandle.cancel(false);
        limiter.shutdown();

        // We may want to allow short bursts of requests in our rate limiting scheme
        // while preserving the overall rate limit. We can accomplish this by using
        // a semaphore. This burstyLimiter will allow bursts of up to 3 events.
        Semaphore burstyLimiter = new Semaphore(3);

        // Every 200 milliseconds we'll add a permit to burstyLimiter, up to its limit of 3.
        ScheduledExecutorService burstyLimiterRefresher = Executors.newScheduledThreadPool(1);
        burstyLimiterRefresher.scheduleAtFixedRate(() -> {
            burstyLimiter.release();
        }, 200, 200, TimeUnit.MILLISECONDS);

        // Now simulate 5 more incoming requests. The first 3 of these will benefit
        // from the burst capability of burstyLimiter.
        BlockingQueue<Integer> burstyRequests = new LinkedBlockingQueue<>();
        for (int i = 1; i <= 5; i++) {
            burstyRequests.offer(i);
        }

        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            executor.submit(() -> {
                try {
                    burstyLimiter.acquire();
                    Integer req = burstyRequests.take();
                    System.out.println("request " + req + " " + Instant.now());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        // Wait for all bursty requests to be processed
        while (!burstyRequests.isEmpty()) {
            Thread.sleep(100);
        }

        executor.shutdown();
        burstyLimiterRefresher.shutdown();
    }
}