API Rate Limiting & Scalability Patterns · บทเรียน

การใช้งานบันทึกหน้าต่างเลื่อน

ทำความเข้าใจอัลกอริทึมบันทึกหน้าต่างเลื่อน ความแม่นยำ และผลต่อพื้นที่จัดเก็บจากการติดตามเวลาของคำขอแต่ละรายการ

การใช้งานบันทึกหน้าต่างเลื่อน เป็นบทเรียน API Rate Limiting & Scalability Patterns ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน API Rate Limiting & Scalability Patterns และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส API Rate Limiting & Scalability Patterns มีบทเรียนทั้งหมด 4 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

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!

คำถามที่พบบ่อย

บทเรียน “การใช้งานบันทึกหน้าต่างเลื่อน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การใช้งานบันทึกหน้าต่างเลื่อน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส API Rate Limiting & Scalability Patterns ให้อัปเกรดเป็น CoddyKit PRO คอร์ส API Rate Limiting & Scalability Patterns มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การใช้งานบันทึกหน้าต่างเลื่อน”

ทำความเข้าใจอัลกอริทึมบันทึกหน้าต่างเลื่อน ความแม่นยำ และผลต่อพื้นที่จัดเก็บจากการติดตามเวลาของคำขอแต่ละรายการ คุณปฏิบัติ API Rate Limiting & Scalability Patterns ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน API Rate Limiting & Scalability Patterns หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน API Rate Limiting & Scalability Patterns บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การใช้งานบันทึกหน้าต่างเลื่อน” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน API Rate Limiting & Scalability Patterns นี้ได้ไหม

ได้ บทเรียน API Rate Limiting & Scalability Patterns ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

การใช้งานบันทึกหน้าต่างเลื่อน
กลยุทธ์ตัวนับหน้าต่างเลื่อน
การเปรียบเทียบอัลกอริทึมและข้อแลกเปลี่ยน
หน้าต่างเลื่อนด้วยเซตเรียงลำดับใน Redis

← กลับไปที่ API Rate Limiting & Scalability Patterns