Đồng thờiConcurrency

Rate Limiteraka Throttling, Token Bucket, Leaky Bucket

Giới hạn số thao tác trong mỗi khoảng thời gian, vẫn cho phép một 'cú bùng' (burst) nhỏ.Cap how many operations happen per unit of time, while still allowing a small burst.

Độ khóDifficulty: VừaMedium
Mức phổ biếnUsage: Mức phổ biếnUsage 5/5
Thời gian đọcReading time: ~9 phút đọc~9 min read

Thảo luậnDiscussion

Ví dụ đời thườngReal-life analogy

Cây ATM chứa tối đa 5 tờ phiếu thứ tự, và cứ 12 giây máy nhả thêm một tờ (đầy thì thôi). Ai tới lấy được phiếu thì được rút tiền; hết phiếu thì phải chờ hoặc quay về. Sáng sớm vắng người, phiếu tích đủ 5 tờ nên 5 người đến cùng lúc vẫn được phục vụ ngay — nhưng về lâu dài không bao giờ quá 5 người mỗi phút.An ATM holds at most 5 queue tickets, and every 12 seconds it prints one more (unless it's full). Whoever gets a ticket may withdraw; no ticket means wait or leave. Early in the morning tickets pile up to 5, so 5 people arriving together are served at once — but over time it never exceeds 5 people per minute.

Vấn đề và giải phápProblem and solution

Không có patternWithout the pattern

Endpoint gửi OTP của app ví điện tử bị bot spam: một số điện thoại nhận 200 SMS trong 1 phút, hoá đơn SMS tăng vọt và nhà mạng cảnh báo. Đồng thời nhà cung cấp SMS chỉ cho gửi 100 tin/giây — vượt là bị trả lỗi hàng loạt. Không có giới hạn tốc độ, một client hung hăng có thể đốt tiền và làm sập trải nghiệm của mọi người.A wallet app's OTP endpoint gets spammed by bots: one phone number receives 200 SMS in a minute, the SMS bill explodes and the carrier complains. Meanwhile the SMS provider only accepts 100 messages per second — exceed it and you get mass errors. Without rate limiting, one aggressive client can burn money and ruin everyone's experience.

Với Rate LimiterWith Rate Limiter

Dùng token bucket: một 'xô' chứa tối đa B token (burst), được nạp đều r token/giây. Mỗi request lấy 1 token; còn token thì đi tiếp, hết thì từ chối (429 + Retry-After) hoặc chờ tới lượt. Giới hạn đặt theo từng khoá (số điện thoại, user, IP) cho chiều VÀO, và một limiter chung cho chiều RA tới nhà cung cấp.Use a token bucket: a 'bucket' holding at most B tokens (the burst), refilled at r tokens/second. Each request takes 1 token; if one is left it proceeds, otherwise it's rejected (429 + Retry-After) or waits its turn. Apply per-key limits (phone, user, IP) on the INBOUND side, and one shared limiter on the OUTBOUND side towards the provider.

Thành phần tham giaParticipants

Bucket: Chứa tối đa B token — chính là độ 'bùng' cho phép.Holds at most B tokens — the allowed burst.
Refill rate: Tốc độ nạp r token/giây — tốc độ trung bình dài hạn.Refill speed r tokens/second — the long-run average rate.
Key: Đơn vị bị giới hạn: user, số điện thoại, IP, API key, hoặc toàn hệ thống.What is limited: user, phone, IP, API key, or the whole system.
Rejection policy: Hết token thì làm gì: từ chối 429, chờ (Wait), hay xếp hàng.What happens without a token: reject with 429, wait, or queue.

Sơ đồ và luồng thực thiDiagram and execution flow

Dùng Tự chạy hoặc phím mũi tên để đi qua từng bước gọi giữa các object. Console hiển thị output tương ứng của chương trình.Use Autoplay or the arrow keys to step through each call between objects. The console shows the matching program output.

1Xô của số 0909... đang đầy 5 token (burst = 5, nạp 5 token/phút).The bucket for 0909... is full with 5 tokens (burst = 5, refill 5 tokens/minute).

← →

console

1limiter[0909]: tokens=5/5

implementsimplementsextendsextendsgọi / dùngcalls / usestạo racreatesgửi qua channelsends via channel1thứ tự chạy (bấm để nhảy bước)execution order (click to jump)

Code: Java Spring Boot ⇄ GoCode: Java Spring Boot ⇄ Go

Cùng một bài toán, hai ngôn ngữ. Rê chuột hoặc focus vào chú thích (số màu cam) để làm nổi bật dòng code tương ứng.Same problem, two languages. Hover or focus an annotation (orange number) to highlight its line.

JavaSpring Boot 3 · Java 21Spring Boot 3 · Java 21

package com.wallet.otp;

import io.github.resilience4j.ratelimiter.RateLimiter;
import io.github.resilience4j.ratelimiter.RateLimiterConfig;
import io.github.resilience4j.ratelimiter.RequestNotPermitted;
import java.time.Duration;
import org.springframework.stereotype.Component;

@Component
public class SmsSender {
    private final SmsProviderClient provider;
    private final RateLimiter limiter;

    public SmsSender(SmsProviderClient provider) {
        this.provider = provider;
        RateLimiterConfig config = RateLimiterConfig.custom()
            .limitForPeriod(100)                       // 100 permits...1
            .limitRefreshPeriod(Duration.ofSeconds(1)) // ...per 1-second cycle
            .timeoutDuration(Duration.ofMillis(500))   // wait at most 500ms2
            .build();
        this.limiter = RateLimiter.of("sms-provider", config);
    }

    // Outbound: protect the provider's 100 msg/s quota
    public boolean send(String phone, String text) {
        try {
            RateLimiter.decorateRunnable(limiter, () -> provider.send(phone, text)).run();3
            return true;
        } catch (RequestNotPermitted e) {
            return false; // caller can enqueue and retry later
        }
    }
}

GoGo 1.23 · thư viện chuẩnGo 1.23 · standard library

package otp

import (
	"context"

	"golang.org/x/time/rate"
)

type SmsSender struct {
	provider Provider
	limiter  *rate.Limiter1
}

func NewSmsSender(p Provider) *SmsSender {
	// Token bucket: refill 100 tokens/s, bucket size (burst) 20
	return &SmsSender{provider: p, limiter: rate.NewLimiter(rate.Limit(100), 20)}2
}

// Outbound: wait for a token instead of failing.
func (s *SmsSender) Send(ctx context.Context, phone, text string) error {
	if err := s.limiter.Wait(ctx); err != nil {3
		return err // ctx cancelled, or the wait would exceed its deadline
	}
	return s.provider.Send(ctx, phone, text)
}

Khác biệt chính giữa Java và GoKey differences between Java and Go

01Go có golang.org/x/time/rate (token bucket, do team Go duy trì). Java không có trong JDK — dùng Resilience4j (chu kỳ cố định, hợp với giới hạn chiều ra) hoặc Bucket4j (token bucket thật, có backend Redis/Hazelcast).Go has golang.org/x/time/rate (a token bucket maintained by the Go team). Java has nothing in the JDK — use Resilience4j (fixed cycles, good for outbound limits) or Bucket4j (a true token bucket with Redis/Hazelcast backends).
02Chờ có huỷ: Go limiter.Wait(ctx) gắn với context; Java dùng timeoutDuration của Resilience4j hoặc bucket.asBlocking().tryConsume(1, maxWait) của Bucket4j.Cancellable waiting: Go's limiter.Wait(ctx) ties into context; Java uses Resilience4j's timeoutDuration or Bucket4j's bucket.asBlocking().tryConsume(1, maxWait).
03Spring gắn limiter bằng annotation (@RateLimiter) hoặc HandlerInterceptor/Filter. Go viết middleware func(http.Handler) http.Handler — chỉ là hàm bọc hàm.Spring attaches limiters via annotations (@RateLimiter) or a HandlerInterceptor/Filter. Go writes a func(http.Handler) http.Handler middleware — just a function wrapping a function.
04Map limiter theo key: Java có ConcurrentHashMap.computeIfAbsent atomic sẵn; Go phải tự khoá map bằng sync.Mutex (hoặc dùng sync.Map).Per-key limiter maps: Java has an atomic ConcurrentHashMap.computeIfAbsent out of the box; Go must lock its map with a sync.Mutex (or use sync.Map).

Ứng dụng thực tếReal-world usage

API Gateway: Kong, Nginx, Spring Cloud GatewayAPI gateways: Kong, Nginx, Spring Cloud Gateway
Plugin rate-limiting của Kong, limit_req của Nginx (leaky bucket), RequestRateLimiter của Spring Cloud Gateway (token bucket trên Redis).Kong's rate-limiting plugin, Nginx limit_req (leaky bucket), Spring Cloud Gateway's RequestRateLimiter (a Redis-backed token bucket).
golang.org/x/time/rate trong hệ sinh thái Gogolang.org/x/time/rate across the Go ecosystem
Kubernetes client-go dùng token bucket để không spam API server; nhiều SDK cloud dùng nó để tôn trọng quota.Kubernetes client-go uses a token bucket to avoid flooding the API server; many cloud SDKs use it to respect quotas.
API công khai: GitHub, Stripe, Zalo OAPublic APIs: GitHub, Stripe, Zalo OA
Trả 429 kèm header X-RateLimit-Remaining / Retry-After — client của bạn cần đọc và lùi lại.They return 429 with X-RateLimit-Remaining / Retry-After headers — your client must read them and back off.
OTP, đăng nhập, flash saleOTP, login, flash sales
Chặn brute-force mật khẩu, spam OTP, và giới hạn mỗi user chỉ bấm 'mua' vài lần/giây trong đợt sale 12.12.Blocks password brute-forcing, OTP spam, and limits each user to a few 'buy' clicks per second during a 12.12 sale.

Khi nào dùng và khi nào khôngWhen to use it, and when not

Nên dùng khiUse it when

Bảo vệ API của bạn khỏi bot, brute-force, client lỗi gọi lặp vô hạn.Protect your API from bots, brute force, and buggy clients looping forever.
Tôn trọng quota của bên thứ ba (SMS, email, cổng thanh toán, OpenAI...).Respect third-party quotas (SMS, email, payment gateways, AI APIs...).
Chia công bằng tài nguyên giữa các tenant/user (gói Free 10 req/s, gói Pro 100 req/s).Share resources fairly between tenants/users (Free plan 10 req/s, Pro plan 100 req/s).

Không nên dùng khiAvoid it when

Vấn đề là số việc chạy ĐỒNG THỜI (5 kết nối) chứ không phải số việc mỗi giây — dùng Semaphore/Bulkhead.The problem is CONCURRENT work (5 connections), not work per second — use a Semaphore/Bulkhead.
Chạy nhiều instance mà cần giới hạn TOÀN CỤC chính xác — limiter trong bộ nhớ thành N × limit; cần Redis/gateway.Many instances needing an exact GLOBAL limit — an in-memory limiter becomes N × limit; use Redis or a gateway.

Ưu điểmPros

Chặn lạm dụng và chi phí bất ngờ ngay từ cửa vào.Stops abuse and surprise costs right at the door.
Burst giữ trải nghiệm mượt cho người dùng thật, refill giữ trung bình ổn định.The burst keeps real users happy; the refill keeps the average steady.
Token bucket rất rẻ: O(1), chỉ vài phép tính trên thời gian, không cần goroutine nền.A token bucket is cheap: O(1), a bit of arithmetic on time, no background goroutine.

Nhược điểmCons

Limiter in-memory không chia sẻ giữa các instance; bản phân tán thêm độ trễ và phụ thuộc Redis.In-memory limiters aren't shared across instances; distributed ones add latency and a Redis dependency.
Map limiter theo key phình to nếu không có cơ chế dọn (expiry/LRU).Per-key limiter maps grow unbounded without cleanup (expiry/LRU).
Chọn sai rate/burst thì chặn nhầm người dùng thật (đặc biệt sau NAT dùng chung IP).Wrong rate/burst values block real users (especially many users behind one NAT IP).

Anti-pattern: lỗi thường gặpAnti-pattern: common mistake

Tạo limiter mới cho mỗi requestCreating a new limiter per request

Limiter tạo bên trong handler luôn bắt đầu với xô ĐẦY, nên Allow() luôn true — không giới hạn được gì. Limiter là trạng thái phải SỐNG LÂU HƠN request: lưu theo key ở tầng ngoài (struct, bean singleton, Redis).A limiter created inside the handler always starts with a FULL bucket, so Allow() is always true — it limits nothing. A limiter is state that must OUTLIVE the request: keep it per key at an outer level (struct, singleton bean, Redis).

func OtpHandler(w http.ResponseWriter, r *http.Request) {
	limiter := rate.NewLimiter(rate.Every(time.Minute), 3) // ❌ fresh full bucket every call
	if !limiter.Allow() { // ❌ always true
		http.Error(w, "slow down", http.StatusTooManyRequests)
		return
	}
	sendOTP(r.FormValue("phone"))
}

Dễ nhầm vớiEasily confused with

Rate Limiter vs Semaphore

Rate limiter: N việc mỗi GIÂY. Semaphore: N việc CÙNG LÚC. Gọi API chậm 10 giây với limit 5 req/s vẫn có thể có 50 request đang treo cùng lúc.Rate limiter: N per SECOND. Semaphore: N AT ONCE. Calling a 10-second API at 5 req/s can still leave 50 requests in flight.

Rate Limiter vs Circuit Breaker

Rate limiter giới hạn tốc độ dù downstream khoẻ mạnh. Circuit breaker chỉ ngắt khi downstream đang LỖI.A rate limiter caps speed even when the downstream is healthy. A circuit breaker only trips when the downstream is FAILING.

Bài tập áp dụngExercise

Thêm giới hạn theo gói: user Free được 10 request/giây (burst 20), user Pro 100 request/giây (burst 200). Xác định user qua header X-User-Id và gói qua một hàm planOf(userID).Add plan-based limits: Free users get 10 req/s (burst 20), Pro users 100 req/s (burst 200). Identify the user via the X-User-Id header and the plan via a planOf(userID) function.

Kiểm tra kiến thứcKnowledge check

Câu 1 / 6Question 1 of 6

Trong token bucket, tham số burst quyết định điều gì?In a token bucket, what does the burst parameter decide?

Phím 1–4 để chọn đáp án, Enter để kiểm tra.Press 1–4 to choose an answer, Enter to check.

Thẻ ghi nhớFlashcards

Ôn tập ngắt quãng (spaced repetition): thẻ được lặp lại sau 1 → 3 → 7 → 14 → 30 ngày để củng cố trí nhớ dài hạn.Spaced repetition: cards are repeated after 1 → 3 → 7 → 14 → 30 days to build long-term memory.

Dùng trong bài toánUsed in problems

3 bài toán Backend dùng pattern này3 backend problems use this pattern

Pattern liên quanRelated patterns

Semaphore Circuit Breaker Retry with Exponential Backoff Proxy

Thảo luậnDiscussion

Rate Limiteraka Throttling, Token Bucket, Leaky Bucket

Giới hạn số thao tác trong mỗi khoảng thời gian, vẫn cho phép một 'cú bùng' (burst) nhỏ.Cap how many operations happen per unit of time, while still allowing a small burst.

VừaMedium

Mức phổ biếnUsage 5/5

~9 phút đọc~9 min read

package com.wallet.otp; import io.github.resilience4j.ratelimiter.RateLimiter; import io.github.resilience4j.ratelimiter.RateLimiterConfig; import io.github.resilience4j.ratelimiter.RequestNotPermitted; import java.time.Duration; import org.springframework.stereotype.Component; @Component public class SmsSender { private final SmsProviderClient provider; private final RateLimiter limiter; public SmsSender(SmsProviderClient provider) { this.provider = provider; RateLimiterConfig config = RateLimiterConfig.custom() .limitForPeriod(100) // 100 permits...1 .limitRefreshPeriod(Duration.ofSeconds(1)) // ...per 1-second cycle .timeoutDuration(Duration.ofMillis(500)) // wait at most 500ms2 .build(); this.limiter = RateLimiter.of("sms-provider", config); } // Outbound: protect the provider's 100 msg/s quota public boolean send(String phone, String text) { try { RateLimiter.decorateRunnable(limiter, () -> provider.send(phone, text)).run();3 return true; } catch (RequestNotPermitted e) { return false; // caller can enqueue and retry later } } }

package otp import ( "context" "golang.org/x/time/rate" ) type SmsSender struct { provider Provider limiter *rate.Limiter1 } func NewSmsSender(p Provider) *SmsSender { // Token bucket: refill 100 tokens/s, bucket size (burst) 20 return &SmsSender{provider: p, limiter: rate.NewLimiter(rate.Limit(100), 20)}2 } // Outbound: wait for a token instead of failing. func (s *SmsSender) Send(ctx context.Context, phone, text string) error { if err := s.limiter.Wait(ctx); err != nil {3 return err // ctx cancelled, or the wait would exceed its deadline } return s.provider.Send(ctx, phone, text) }

func OtpHandler(w http.ResponseWriter, r *http.Request) { limiter := rate.NewLimiter(rate.Every(time.Minute), 3) // ❌ fresh full bucket every call if !limiter.Allow() { // ❌ always true http.Error(w, "slow down", http.StatusTooManyRequests) return } sendOTP(r.FormValue("phone")) }