API Rate Limiting & Scalability Patterns · Lektion

Implementierung des Sliding-Window-Logs

Verstehen Sie den Sliding-Window-Log-Algorithmus, seine Präzision und die Auswirkungen auf den Speicherbedarf bei der Erfassung einzelner Anfragezeitpunkte.

Lektion 1 von 411 Schritte

Implementierung des Sliding-Window-Logs ist eine kostenlose API Rate Limiting & Scalability Patterns-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des API Rate Limiting & Scalability Patterns-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der API Rate Limiting & Scalability Patterns-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

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?

Beantworte es in der interaktiven Lektion

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!

Kostenlos starten

Lerne API Rate Limiting & Scalability Patterns mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 12
Lektionen: 48

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Implementierung des Sliding-Window-Logs“ kostenlos?

Ja — der vollständige Text von „Implementierung des Sliding-Window-Logs“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des API Rate Limiting & Scalability Patterns-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der API Rate Limiting & Scalability Patterns-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Implementierung des Sliding-Window-Logs“?

Verstehen Sie den Sliding-Window-Log-Algorithmus, seine Präzision und die Auswirkungen auf den Speicherbedarf bei der Erfassung einzelner Anfragezeitpunkte. Du übst API Rate Limiting & Scalability Patterns mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um API Rate Limiting & Scalability Patterns zu starten?

Keine Vorkenntnisse erforderlich. API Rate Limiting & Scalability Patterns auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Implementierung des Sliding-Window-Logs“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser API Rate Limiting & Scalability Patterns-Lektion Code schreiben und ausführen?

Ja. Jede API Rate Limiting & Scalability Patterns-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu API Rate Limiting & Scalability Patterns