Mønstre for API-ratebegrensning og skalerbarhet · leksjon

Implementering av Sliding Window Log

Forstå algoritmen Sliding Window Log, presisjonen den gir, og lagringskonsekvensene ved sporing av tidsstemplene til individuelle forespørsler.

Leksjon 1 av 411 trinn

Implementering av Sliding Window Log er en gratis leksjon i Mønstre for API-ratebegrensning og skalerbarhet på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Mønstre for API-ratebegrensning og skalerbarhet, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Mønstre for API-ratebegrensning og skalerbarhet inneholder totalt 4 leksjoner.

Introduksjon til Sliding Window Log

Velkommen til Sliding Window Log-algoritmen! Denne metoden gir en svært presis måte å håndheve hastighetsgrenser for API-er på.

I motsetning til enklere metoder fører den en detaljert oversikt over hver forespørsel, noe som gir svært nøyaktig kontroll over trafikken.

Kjernen i tidsstempelloggen

Kjerneideen i Sliding Window Log er å lagre det nøyaktige tidsstempelet for hver forespørsel fra en klient.

Se for Dem en liste eller en tabell.
Hver gang en forespørsel sendes, legges det aktuelle klokkeslettet (for eksempel i millisekunder) til i listen.
Denne loggen gjør det mulig å spore aktiviteten nøyaktig i en hvilken som helst gitt periode.

Loggføring av nye forespørsler

Når en ny forespørsel kommer inn, utfører algoritmen to hovedtrinn:

Den registrerer det aktuelle klokkeslettet og legger det til i listen over tidsstempler for forespørsler.
Deretter rydder den bort gamle tidsstempler som ikke lenger er relevante for det gjeldende «glidende» vinduet.

Dette sikrer at loggen bare inneholder nylige, aktive forespørsler.

Kontroll av det glidende vinduet

For å avgjøre om en ny forespørsel skal tillates, beregner algoritmen et glidende vindu.

For en grense på 60 sekunder, hvis det aktuelle klokkeslettet er T, dekker vinduet forespørsler fra T - 60 seconds til T.
Den teller hvor mange tidsstempler i loggen som faller innenfor dette beregnede vinduet.
Hvis antallet er lavere enn den tillatte grensen, tillates forespørselen.

Visualisering av vinduets bevegelse

Tenk på vinduet som en sammenhengende periode som «glir» fremover med hver nye forespørsel.

Hvis grensen er 3 forespørsler per 5 sekunder:

Ved t=0 er vinduet [-5s, 0s].
Ved t=2s er vinduet [-3s, 2s].
Ved t=6s er vinduet [1s, 6s].

Bare tidsstempler innenfor det gjeldende glidende vinduet telles.

Oppsett av limiter-klassen

La oss sette opp en enkel Java-klasse for hastighetsbegrenseren vår basert på Sliding Window Log. Vi bruker en ArrayList til å lagre tidsstemplene for forespørslene.

Prøv å kjøre dette for å se det innledende oppsettet:

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!");
    }
}

Implementering av allowRequest()

La oss nå implementere kjernefunksjonaliteten i metoden allowRequest(). Denne metoden fjerner gamle tidsstempler og kontrollerer om den aktuelle forespørselen kan tillates.

Kjør koden for å se en enkel test av hastighetsbegrenseren i praksis!

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"));
    }
}

Viktig fordel: høy presisjon

Den største styrken ved Sliding Window Log-algoritmen er dens høye presisjon.

Fordi den registrerer hvert enkelt tidsstempel, kan den beregne antallet forespørsler i et dynamisk vindu nøyaktig.
Dette fjerner problemet med «trafikktopper» som finnes i Fixed Window Counter, der en plutselig økning ved kanten av vinduet kan omgå grensene.

Utfordringen med minne og ytelse

Selv om Sliding Window Log er presis, har den betydelige ulemper, særlig for API-er med høyt volum:

Minnebruk: Lagring av tidsstempelet for millioner av forespørsler kan bruke mye minne.
Ytelse: Operasjoner som å legge til nye tidsstempler og fjerne gamle (særlig i store lister) kan bli trege og påvirke ytelsen.

Dette gjør algoritmen mindre egnet for systemer med svært høy gjennomstrømning, med mindre den optimaliseres.

Test forståelsen Deres

Vurder Sliding Window Log-algoritmen. Hvilke av følgende påstander stemmer om egenskapene dens?

Besvar den i den interaktive leksjonen

Oppsummering: Sliding Window Log

I denne leksjonen utforsket vi Sliding Window Log-algoritmen:

Den sporer hver forespørsel ved hjelp av det nøyaktige tidsstempelet.
Den gir høy presisjon og unngår problemet med «trafikktopper» i faste vinduer.
De viktigste ulempene er høy minnebruk og mulige ytelsesflaskehalser for svært store logger over forespørsler.

Deretter skal vi se på Sliding Window Counter, som har som mål å forbedre disse ulempene!

Gratis å komme i gang

Lær deg Mønstre for API-ratebegrensning og skalerbarhet med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Implementering av Sliding Window Log» gratis?

Ja – hele teksten i «Implementering av Sliding Window Log» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Mønstre for API-ratebegrensning og skalerbarhet-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Mønstre for API-ratebegrensning og skalerbarhet inneholder totalt 4 leksjoner.

Hva lærer jeg i «Implementering av Sliding Window Log»?

Forstå algoritmen Sliding Window Log, presisjonen den gir, og lagringskonsekvensene ved sporing av tidsstemplene til individuelle forespørsler. Du øver på Mønstre for API-ratebegrensning og skalerbarhet med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Mønstre for API-ratebegrensning og skalerbarhet?

Ingen tidligere erfaring er nødvendig. Mønstre for API-ratebegrensning og skalerbarhet på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Implementering av Sliding Window Log»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Mønstre for API-ratebegrensning og skalerbarhet-leksjonen?

Ja. Alle Mønstre for API-ratebegrensning og skalerbarhet-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Implementering av Sliding Window Log
Strategien Sliding Window Counter
Sammenligning av algoritmer og avveininger
Glidende vindu med sorterte mengder i Redis

← Tilbake til Mønstre for API-ratebegrensning og skalerbarhet