고정 윈도우 카운터 처리율 제한 구현

Author: gunkim

rate-limiter/src/main/java/io/github/gunkim/ratelimiter/window/FixedWindowRateLimiter.java

@@ -0,0 +1,47 @@
+package io.github.gunkim.ratelimiter.window;
+
+import io.github.gunkim.ratelimiter.RateLimiter;
+
+import java.time.Instant;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class FixedWindowRateLimiter implements RateLimiter {
+    private final int maxRequestsPerWindow;
+    private final int windowDurationMillis;
+    private final ConcurrentHashMap<Long, AtomicInteger> requestCounts = new ConcurrentHashMap<>();
+
+    public FixedWindowRateLimiter(int maxRequestsPerWindow, int windowDurationMillis) {
+        this.maxRequestsPerWindow = maxRequestsPerWindow;
+        this.windowDurationMillis = windowDurationMillis;
+    }
+
+    @Override
+    public void request(Runnable request) {
+        long currentTimeMillis = Instant.now().toEpochMilli();
+        long currentWindowKey = currentTimeMillis / windowDurationMillis;
+
+        cleanupOldWindows(currentWindowKey);
+
+        AtomicInteger currentWindowRequestCount = getOrCreateRequestCounterForWindow(currentWindowKey);
+        currentWindowRequestCount.incrementAndGet();
+
+        if (currentWindowRequestCount.get() <= maxRequestsPerWindow) {
+            request.run();
+        } else {
+            currentWindowRequestCount.decrementAndGet();
+        }
+    }
+
+    private AtomicInteger getOrCreateRequestCounterForWindow(long currentWindowKey) {
+        return requestCounts.computeIfAbsent(currentWindowKey, k -> new AtomicInteger(0));
+    }
+
+    private void cleanupOldWindows(long currentWindowKey) {
+        requestCounts.forEach((windowKey, count) -> {
+            if (windowKey < currentWindowKey) {
+                requestCounts.remove(windowKey);
+            }
+        });
+    }
+}

rate-limiter/src/test/java/io/github/gunkim/ratelimiter/window/FixedWindowRateLimiterTest.java

@@ -0,0 +1,58 @@
+package io.github.gunkim.ratelimiter.window;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+@DisplayName("FixedWindowRateLimiter는")
+class FixedWindowRateLimiterTest {
+    private static final int WINDOW_SIZE = 10_000;
+    private static final int REQUESTS_LIMIT = 2;
+
+    @Test
+    void window_size_이내_요청은_처리된다() {
+        Runnable runnable = mock(Runnable.class);
+        FixedWindowRateLimiter rateLimiter = createRateLimiter(10);
+        rateLimiter.request(runnable);
+        verify(runnable, times(1)).run();
+    }
+
+    @Test
+    void window_size가_2이고_요청이_3회라면_2회만_처리된다() throws InterruptedException {
+        int requestCount = 3;
+        AtomicInteger counter = new AtomicInteger(0);
+        CountDownLatch countDownLatch = new CountDownLatch(REQUESTS_LIMIT);
+        Runnable request = createRunnable(counter, countDownLatch);
+
+        FixedWindowRateLimiter rateLimiter = createRateLimiter(REQUESTS_LIMIT);
+        sendRequests(rateLimiter, request, requestCount);
+
+        countDownLatch.await(1, TimeUnit.SECONDS);
+        assertThat(counter.get()).isEqualTo(REQUESTS_LIMIT);
+    }
+
+    private FixedWindowRateLimiter createRateLimiter(int limit) {
+        return new FixedWindowRateLimiter(limit, WINDOW_SIZE);
+    }
+
+    private Runnable createRunnable(AtomicInteger counter, CountDownLatch countDownLatch) {
+        return () -> {
+            counter.incrementAndGet();
+            countDownLatch.countDown();
+        };
+    }
+
+    private void sendRequests(FixedWindowRateLimiter rateLimiter, Runnable request, int requestCount) {
+        for (int i = 0; i < requestCount; i++) {
+            rateLimiter.request(request);
+        }
+    }
+}