슬라이딩 윈도우 처리 제한 알고리즘 구현

Author: gunkim

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

@@ -0,0 +1,56 @@
+package io.github.gunkim.ratelimiter.window;
+
+import io.github.gunkim.ratelimiter.RateLimiter;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * ## 처리 제한 알고리즘, 슬라이딩 윈도우 카운터
+ * - 슬라이딩 윈도우 기법을 사용하여 고정된 간격의 윈도 내에서 요청을 제한한다.
+ * - 현재 윈도와 이전 윈도의 요청을 샘플링하고, 가중치를 부여하여 전체 요청 수를 계산한다.
+ * - 임계치를 넘어선 요청은 거부된다.
+ * <p>
+ * 이 방식을 사용하면 윈도 경계에서의 집중된 트래픽 문제를 완화할 수 있다.
+ * 예를 들어,
+ * - 윈도 크기가 1분이고 임계치가 100이라고 가정할 때,
+ * - 12:00:30에서 12:01:30까지의 1분간의 요청 중 일부는 새로운 윈도로 넘어가서 가중치를 부여받는다.
+ * - 이는 고정된 윈도우 카운터에서 발생할 수 있는 200개의 요청이 처리되는 문제를 감소시킨다.
+ */
+public class SlidingWindowRateLimiter implements RateLimiter {
+    private final int windowDurationMillis;
+    private final int maxRequestsPerWindow;
+    private final TimeProvider timeProvider;
+
+    private final ConcurrentHashMap<Long, AtomicInteger> windowCounterMap = new ConcurrentHashMap<>();
+
+    public SlidingWindowRateLimiter(int windowDurationMillis, int maxRequestsPerWindow, TimeProvider timeProvider) {
+        this.windowDurationMillis = windowDurationMillis;
+        this.maxRequestsPerWindow = maxRequestsPerWindow;
+        this.timeProvider = timeProvider;
+    }
+
+    @Override
+    public void handleRequest(Runnable request) {
+        long currentMillis = timeProvider.getCurrentTimeMillis();
+        long currentWindowKey = currentMillis / windowDurationMillis;
+        long previousWindowKey = currentWindowKey - 1;
+
+        double elapsedRatio = (double) (currentMillis % windowDurationMillis) / windowDurationMillis;
+
+        AtomicInteger currentCounter = windowCounterMap.computeIfAbsent(currentWindowKey, k -> new AtomicInteger(0));
+        AtomicInteger previousCounter = windowCounterMap.getOrDefault(previousWindowKey, new AtomicInteger(0));
+
+        // 이전 윈도우의 카운트를 가중치를 적용하여 계산
+        double weightedPreviousCount = previousCounter.get() * (1 - elapsedRatio);
+        long totalRequestCount = (long) (currentCounter.get() + weightedPreviousCount);
+
+        if (totalRequestCount < maxRequestsPerWindow) {
+            request.run();
+            currentCounter.incrementAndGet();
+        }
+
+        // 오래된 윈도우 제거 (현재 윈도우와 이전 윈도우만 유지)
+        windowCounterMap.entrySet().removeIf(entry -> entry.getKey() < previousWindowKey);
+    }
+}

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

@@ -0,0 +1,6 @@
+package io.github.gunkim.ratelimiter.window;
+
+@FunctionalInterface
+public interface TimeProvider {
+    long getCurrentTimeMillis();
+}

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

@@ -0,0 +1,97 @@
+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 java.util.concurrent.atomic.AtomicLong;
+
+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("SlidingWindowRateLimiter는")
+class SlidingWindowRateLimiterTest {
+    private static final int WINDOW_SIZE = 1_000;
+    private static final int REQUESTS_LIMIT = 5;
+
+    @Test
+    void window_size_이내_요청은_처리된다() {
+        SlidingWindowRateLimiter rateLimiter = createRateLimiter();
+        executeAndVerifyRequest(rateLimiter, 1);
+    }
+
+    @Test
+    void 제한_초과_요청은_처리되지_않는다() throws InterruptedException {
+        SlidingWindowRateLimiter rateLimiter = createRateLimiter();
+        var counter = new AtomicInteger(0);
+        var countDownLatch = new CountDownLatch(REQUESTS_LIMIT);
+
+        executeBulkRequests(rateLimiter, counter, countDownLatch, REQUESTS_LIMIT + 3);
+
+        countDownLatch.await(1, TimeUnit.SECONDS);
+        assertThat(counter.get()).isEqualTo(REQUESTS_LIMIT);
+    }
+
+    @Test
+    void 슬라이딩_윈도우_동작을_만족한다() {
+        var currentTime = new AtomicLong(0);
+        TimeProvider timeProvider = currentTime::get;
+        var rateLimiter = new SlidingWindowRateLimiter(WINDOW_SIZE, REQUESTS_LIMIT, timeProvider);
+
+        int totalRequests = sendAllWindowRequests(rateLimiter, currentTime);
+
+        assertThat(totalRequests)
+                .isGreaterThan(REQUESTS_LIMIT)
+                .isLessThanOrEqualTo(REQUESTS_LIMIT * 2);
+    }
+
+    private int sendAllWindowRequests(SlidingWindowRateLimiter rateLimiter, AtomicLong currentTime) {
+        int firstWindowRequests = sendRequests(rateLimiter, REQUESTS_LIMIT + 2, currentTime);
+        assertThat(firstWindowRequests)
+                .as("임계치에 대한 제한이 정상적으로 구현되었는지 확인해보세요.")
+                .isEqualTo(REQUESTS_LIMIT);
+
+        currentTime.addAndGet(WINDOW_SIZE / 2);
+        int secondWindowRequests = sendRequests(rateLimiter, REQUESTS_LIMIT, currentTime);
+        assertThat(secondWindowRequests).isZero();
+
+        currentTime.addAndGet(WINDOW_SIZE / 2);
+        int thirdWindowRequests = sendRequests(rateLimiter, REQUESTS_LIMIT, currentTime);
+        assertThat(thirdWindowRequests).isEqualTo(1);
+
+        return firstWindowRequests + secondWindowRequests + thirdWindowRequests;
+    }
+
+    private int sendRequests(SlidingWindowRateLimiter rateLimiter, int count, AtomicLong currentTime) {
+        var successCount = new AtomicInteger();
+        for (int i = 0; i < count; i++) {
+            rateLimiter.handleRequest(successCount::getAndIncrement);
+            currentTime.addAndGet(1); // 각 요청마다 1ms 증가
+        }
+        return successCount.get();
+    }
+
+    private void executeBulkRequests(SlidingWindowRateLimiter rateLimiter, AtomicInteger counter, CountDownLatch latch, int count) {
+        for (int i = 0; i < count; i++) {
+            rateLimiter.handleRequest(() -> {
+                counter.incrementAndGet();
+                latch.countDown();
+            });
+        }
+    }
+
+    private SlidingWindowRateLimiter createRateLimiter() {
+        var currentTime = new AtomicLong(0);
+        return new SlidingWindowRateLimiter(WINDOW_SIZE, REQUESTS_LIMIT, currentTime::get);
+    }
+
+    private void executeAndVerifyRequest(SlidingWindowRateLimiter rateLimiter, int times) {
+        Runnable runnable = mock(Runnable.class);
+        rateLimiter.handleRequest(runnable);
+        verify(runnable, times(times)).run();
+    }
+}