API Rate Limiting & Scalability Patterns · Ders

Kayan Zaman Aralığı Günlüğü Uygulaması

Kayan Zaman Aralığı Günlüğü algoritmasını, hassasiyetini ve tek tek istek zaman damgalarını izlemenin depolama açısından etkilerini anlayın.

Kayan Zaman Aralığı Günlüğü Uygulaması, CoddyKit'te ücretsiz bir API Rate Limiting & Scalability Patterns dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, API Rate Limiting & Scalability Patterns öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. API Rate Limiting & Scalability Patterns kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

Intro to Sliding Window Log

Welcome to the Sliding Window Log algorithm! This method offers a highly precise way to enforce API rate limits.

Unlike simpler methods, it keeps a detailed record of each request, allowing for very accurate control over traffic.

The Timestamp Log Core

The core idea of the Sliding Window Log is to store the exact timestamp of every request made by a client.

Imagine a list or array.
Each time a request is made, its current time (e.g., in milliseconds) is added to this list.
This log allows us to precisely track activity over any given period.

Logging New Requests

When a new request arrives, the algorithm performs two main steps:

It records the current time and adds it to the list of request timestamps.
It then cleans up old timestamps that are no longer relevant to the current 'sliding' window.

This ensures the log only contains recent, active requests.

Checking the Sliding Window

To determine if a new request should be allowed, the algorithm calculates a sliding window.

For a 60-second limit, if the current time is T, the window covers requests from T - 60 seconds to T.
It counts how many timestamps in the log fall within this calculated window.
If the count is below the allowed limit, the request is permitted.

Visualizing Window Movement

Think of the window as a continuous period that 'slides' forward with each new request.

If your limit is 3 requests per 5 seconds:

At t=0, window is [-5s, 0s].
At t=2s, window is [-3s, 2s].
At t=6s, window is [1s, 6s].

Only timestamps within the current sliding window are counted.

Limiter Class Setup

Let's set up a basic Java class for our Sliding Window Log rate limiter. We'll use an ArrayList to store the request timestamps.

Try running this to see the initial setup:

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class SlidingWindowLogRateLimiter {
    private final List<Long> requestTimestamps;
    private final long windowSizeMillis; // e.g., 60_000 for 60 seconds
    private final int maxRequests;

    public SlidingWindowLogRateLimiter(long windowSize, TimeUnit unit, int maxRequests) {
        this.requestTimestamps = new ArrayList<>();
        this.windowSizeMillis = unit.toMillis(windowSize);
        this.maxRequests = maxRequests;
    }

    // The allowRequest() method will be added next!
    public static void main(String[] args) {
        System.out.println("Rate Limiter setup complete!");
    }
}

Implementing allowRequest()

Now, let's implement the core logic for the allowRequest() method. This method will remove old timestamps and check if the current request can be allowed.

Run the code to see a simple test of the rate limiter in action!

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class SlidingWindowLogRateLimiter {
    private final List<Long> requestTimestamps;
    private final long windowSizeMillis;
    private final int maxRequests;

    public SlidingWindowLogRateLimiter(long windowSize, TimeUnit unit, int maxRequests) {
        this.requestTimestamps = new ArrayList<>();
        this.windowSizeMillis = unit.toMillis(windowSize);
        this.maxRequests = maxRequests;
    }

    public synchronized boolean allowRequest() {
        long currentTime = System.currentTimeMillis();
        long windowStartTime = currentTime - windowSizeMillis;

        // Remove timestamps older than the current window
        requestTimestamps.removeIf(timestamp -> timestamp <= windowStartTime);

        // Check if adding a new request would exceed the limit
        if (requestTimestamps.size() < maxRequests) {
            requestTimestamps.add(currentTime);
            return true;
        }
        return false;
    }

    public static void main(String[] args) throws InterruptedException {
        // Example: 3 requests allowed per 5 seconds
        SlidingWindowLogRateLimiter limiter =
            new SlidingWindowLogRateLimiter(5, TimeUnit.SECONDS, 3);

        System.out.println("Testing 5s, 3 requests limit:");
        for (int i = 0; i < 5; i++) {
            boolean allowed = limiter.allowRequest();
            System.out.println("Request " + (i + 1) + ": " + (allowed ? "Allowed" : "Blocked"));
            if (i == 2) Thread.sleep(1000); // Small delay to simulate real traffic
        }
        // Wait for the window to pass to allow more requests
        System.out.println("Waiting 5 seconds for window reset...");
        Thread.sleep(5000);
        System.out.println("Request after window reset: " + (limiter.allowRequest() ? "Allowed" : "Blocked"));
    }
}

Key Advantage: High Precision

The biggest strength of the Sliding Window Log algorithm is its high precision.

Because it records every individual timestamp, it can accurately calculate the number of requests within any dynamic window.
This eliminates the 'burstiness' problem seen in Fixed Window Counters, where a sudden spike at the window's edge could bypass limits.

The Memory & Performance Challenge

While precise, the Sliding Window Log has significant drawbacks, especially for high-volume APIs:

Memory Usage: Storing every timestamp for millions of requests can consume a lot of memory.
Performance: Operations like adding new timestamps and removing old ones (especially with large lists) can become slow, impacting performance.

This makes it less suitable for extremely high-throughput systems unless optimized.

Check Your Understanding

Consider the Sliding Window Log algorithm. Which of the following statements are true about its characteristics?

Recap: Sliding Window Log

In this lesson, we explored the Sliding Window Log algorithm:

It tracks every request by its exact timestamp.
It offers high precision, avoiding the 'burst' issue of fixed windows.
Its main drawbacks are high memory usage and potential performance bottlenecks for very large request logs.

Next, we'll look at the Sliding Window Counter, which aims to improve on these drawbacks!

Sıkça Sorulan Sorular

“Kayan Zaman Aralığı Günlüğü Uygulaması” dersi ücretsiz mi?

Evet — “Kayan Zaman Aralığı Günlüğü Uygulaması” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve API Rate Limiting & Scalability Patterns kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. API Rate Limiting & Scalability Patterns kursu toplamda 4 dersten oluşur.

“Kayan Zaman Aralığı Günlüğü Uygulaması” dersinde ne öğreneceğim?

Kayan Zaman Aralığı Günlüğü algoritmasını, hassasiyetini ve tek tek istek zaman damgalarını izlemenin depolama açısından etkilerini anlayın. API Rate Limiting & Scalability Patterns ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

API Rate Limiting & Scalability Patterns öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te API Rate Limiting & Scalability Patterns, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“Kayan Zaman Aralığı Günlüğü Uygulaması” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu API Rate Limiting & Scalability Patterns dersinde kod yazıp çalıştırabilir miyim?

Evet. Her API Rate Limiting & Scalability Patterns dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

Kayan Zaman Aralığı Günlüğü Uygulaması
Kayan Zaman Aralığı Sayacı Stratejisi
Algoritma Karşılaştırması ve Ödünleşimler
Redis'te Sıralı Kümelerle Kayan Pencere

← API Rate Limiting & Scalability Patterns Sayfasına Dön