---
title: "Retry với backoff và jitter: gọi lại API lỗi mà không làm sập server"
description: "Retry là gì: gọi lại khi lỗi tạm dễ thành thundering herd; exponential backoff chưa đủ, cần jitter để lệch nhịp và đo đỉnh request theo giây."
canonical: "https://200lab.io/blog/retry-la-gi"
published: "2026-11-15T02:00:00Z"
updated: "2026-11-15T02:00:00Z"
authors: ["Việt Trần"]
tags: ["Backend", "System Design"]
reading_minutes: 17
access: "public"
---

Giả sử cổng thanh toán mà hệ thống của bạn kết nối bị chập chờn khoảng 30 giây, khiến hàng loạt client cùng nhận lỗi rồi tự động gọi lại. **Retry là việc client tự gửi lại request khi gặp lỗi tạm thời; kèm exponential backoff và jitter, các lần gửi lại được giãn ra và lệch nhịp để server kịp hồi phục.**

Nếu tất cả client đều cài đặt thời gian chờ giống nhau, ngay khoảnh khắc cổng thanh toán vừa hồi phục, cả đàn request sẽ ập vào trong cùng một giây. Cú dồn tải đột ngột này dễ làm cho server vừa hồi phục lại sập ngay sau đó. Trong bài này, mình giải thích retry, exponential backoff, vì sao cần jitter, rồi chạy thử chương trình mô phỏng 200 client bằng Go để nhìn con số cụ thể.

## Retry là gì và thundering herd xảy ra lúc nào

Trong lập trình backend, retry là hành động client tự động gửi lại một request khi vừa gặp lỗi tạm thời như kết nối đứt quãng, request bị timeout do quá thời gian chờ phản hồi, hoặc server trả về [HTTP status code nhóm 5xx](/blog/http-status-code). Với những trục trặc thoáng qua trên đường truyền network, việc thử lại ngay sau đó một chút thường giúp request thành công.

Tuy nhiên, không phải loại lỗi nào chúng ta cũng nên gọi lại. Với nhóm lỗi 4xx do dữ liệu gửi lên sai định dạng hoặc thiếu quyền truy cập, việc bạn cố retry thêm chục lần thì kết quả trả về vẫn là lỗi đó. Vì vậy, bước đầu tiên khi thiết kế cơ chế này là phải phân loại rõ lúc nào được phép gọi lại và lúc nào cần dừng ngay.

Mọi chuyện trở nên nguy hiểm khi hệ thống có nhiều client cùng gặp lỗi và thực hiện retry theo một nhịp giống nhau. Hiện tượng này gọi là thundering herd, giống như một đàn client đập cùng nhịp vào cửa server vào đúng một thời điểm.

![Nhiều client retry cùng nhịp dồn vào server đang hồi phục, khiến server quá tải lại](https://assets.200lab.io/sha256/56/56e170016696636d75bf0e60e69787811436714d1b4f8679a6986642d956138c/generations/1b54c4457e55d5ede45c58cbbd2b320dfc734d182d9a397fc46c6e61d6890980)

Theo tài liệu [Timeouts, retries, and backoff with jitter](https://aws.amazon.com/builders-library/timeouts-retries-and-backoff-with-jitter/) trên Amazon Builders' Library, việc retry đồng loạt tỏ ra kém hiệu quả nếu nguyên nhân gây lỗi ban đầu xuất phát từ sự quá tải. Khi server đang xử lý không kịp, hành động gọi lại dồn dập từ phía client chỉ làm tăng thêm tải, khiến service đang cố gắng hồi phục lại bị nhấn chìm bởi chính lưu lượng gọi lại này.

## Exponential backoff làm chậm retry, nhưng vẫn đi cùng nhịp

Để giảm áp lực gõ cửa liên tục, giải pháp phổ biến là exponential backoff: sau mỗi lần gọi thất bại, thời gian chờ trước lần thử tiếp theo tăng dần theo cấp số nhân, đi kèm mức trần gọi là cap để khoảng chờ không kéo dài quá mức.

Trong bản chạy thử ở phần sau, mình đặt mức chờ cơ sở 1 giây và trần 16 giây. Lần lỗi đầu client ngủ 1 giây rồi gọi lại, nếu vẫn lỗi thì nâng lên 2 giây, 4 giây, 8 giây rồi chạm trần 16 giây.

Dù vậy, thực tế vẫn còn một lỗ hổng lớn về mặt thời điểm. Giả sử lúc giây thứ 0, có 200 client cùng gọi vào cổng thanh toán và bị từ chối cùng lúc. Vì tất cả dùng chung công thức tính thời gian chờ, cả 200 client này sẽ cùng im lặng, rồi cùng thức dậy vào đúng giây thứ 1, thứ 3, thứ 7 và thứ 15.

Trong bài viết [Exponential Backoff and Jitter](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/) trên AWS Architecture Blog năm 2015, tác giả Marc Brooker đã chỉ rõ vấn đề này. Ông giải thích rằng cơ chế exponential backoff khi thiếu yếu tố ngẫu nhiên vẫn để các lần gọi bị dồn lại thành từng cụm lớn. Tức là chúng ta chỉ kéo giãn khoảng cách giữa các đợt sóng đập vào server, chứ mỗi đợt sóng vẫn giữ nguyên sức nặng của cả đàn client cộng lại.

## Jitter làm lệch nhịp retry

Để phá vỡ sự đồng thanh kia, người ta đưa jitter vào công thức tính thời gian chờ: cộng hoặc nhân thêm một khoảng thời gian ngẫu nhiên vào lịch trình ngủ của từng client. Khi mỗi tiến trình tự bốc thăm một con số riêng, thời điểm chúng thức dậy và gửi request sẽ lệch nhịp.

Theo mô tả của Marc Brooker trên AWS, cách cài đặt có tên full jitter sẽ cho client ngủ một khoảng ngẫu nhiên nằm trong đoạn từ 0 cho đến mức backoff hiện tại. Công thức tính giới hạn trên của khoảng ngẫu nhiên này là lấy giá trị nhỏ hơn giữa mức trần `cap` và tích của `base * 2^attempt`. Như vậy, thời gian chờ thực tế có thể rơi vào bất kỳ thời điểm nào từ ngay lập tức cho đến sát mức trần của bước đó.

![Backoff không jitter thức dậy đúng giây cố định, full jitter bốc thời gian chờ ngẫu nhiên trong từng khoảng](https://assets.200lab.io/sha256/49/4922b59db4a7dbeeccb523e8c9f97eac4ed87d18f7254a341b8500a759177d21/generations/764c0d849b202f49c3e7cdb4c3d0b7f612e0bda466627e7d892776b04a3cef27)

Ngoài ra, bài viết của AWS còn nêu hai biến thể khác là Equal Jitter và Decorrelated Jitter. Trong bài này, mình chỉ chọn chạy thử nghiệm với full jitter để bạn dễ đối chiếu số liệu, và việc chọn biến thể nào sẽ tùy thuộc vào đặc thù bài toán của bạn.

Theo Amazon Builders' Library, mục đích cốt lõi của jitter là tránh các đợt bùng nổ lưu lượng khi mọi client cùng thức dậy một lượt. Trong bài viết trên AWS, khi tác giả mô phỏng cơ chế optimistic concurrency control (OCC) với 100 client tranh chấp, full jitter đã giúp giảm hơn một nửa số lần gọi để hoàn thành công việc so với exponential backoff không có jitter. Bạn lưu ý con số giảm hơn một nửa này thuộc về bài toán OCC của phía AWS, không phải số liệu từ bản demo 200 client bên dưới của chúng ta.

## Chạy thử 200 client: cố định, backoff và full jitter

Mình viết một chương trình Go mô phỏng lại tình huống ở đầu bài. Chương trình chạy giả lập trên máy với bộ sinh số ngẫu nhiên seed 42 để cố định kết quả, không gọi cổng thanh toán thật. Kịch bản: 200 client cùng gửi request ở t=0 khi server đang sập, đến t=30 giây thì server sống lại.

Chương trình đã chạy thật, đếm số request rơi vào từng khoảng một giây trên ba kịch bản. A: mỗi lần lỗi thì chờ cố định 1 giây rồi gọi lại. B: exponential backoff với cơ sở 1 giây và trần 16 giây. C: giữ thông số của B, trộn thêm full jitter.

Chúng ta thử xem đoạn code dưới đây nha:

```go
// Compare three retry schedules for 200 clients after a 30s outage:
// fixed interval, exponential backoff, and exponential backoff with full jitter.
//
// Illustrative simulation only. It does not call a real payment API.
// Full jitter follows the common "sleep in [0, cap]" rule described in
// Amazon Builders' Library / AWS Architecture Blog (Exponential Backoff And Jitter).
package main

import (
	"fmt"
	"math"
	"math/rand"
	"sort"
)

const (
	clients     = 200
	outageSec   = 30.0
	horizonSec  = 48.0
	fixedWait   = 1.0
	backoffBase = 1.0
	backoffCap  = 16.0
	maxAttempts = 64
	binSec      = 1.0
	jitterSeed  = 42
)

type strategy int

const (
	fixedInterval strategy = iota
	expBackoff
	expBackoffFullJitter
)

func (s strategy) name() string {
	switch s {
	case fixedInterval:
		return "fixed interval (1s)"
	case expBackoff:
		return "exponential backoff (no jitter)"
	default:
		return "exponential backoff + full jitter"
	}
}

func waitSec(s strategy, attempt int, rng *rand.Rand) float64 {
	// attempt is 0-based for the retry after a failure.
	exp := math.Min(backoffCap, backoffBase*math.Pow(2, float64(attempt)))
	switch s {
	case fixedInterval:
		return fixedWait
	case expBackoff:
		return exp
	default:
		// Full jitter: uniform in [0, cap). Float64() returns a value in
		// [0, 1), so the wait can be 0 but never reaches cap exactly.
		if exp <= 0 {
			return 0
		}
		return rng.Float64() * exp
	}
}

func simulate(s strategy, seed int64) []float64 {
	rng := rand.New(rand.NewSource(seed))
	var hits []float64
	for c := 0; c < clients; c++ {
		t := 0.0
		for attempt := 0; attempt < maxAttempts; attempt++ {
			if t > horizonSec {
				break
			}
			hits = append(hits, t)
			if t >= outageSec {
				// First request after the gateway is back succeeds.
				break
			}
			t += waitSec(s, attempt, rng)
		}
	}
	sort.Float64s(hits)
	return hits
}

func histogram(hits []float64) []int {
	n := int(math.Ceil(horizonSec / binSec))
	bins := make([]int, n)
	for _, t := range hits {
		i := int(math.Floor(t / binSec))
		if i >= 0 && i < n {
			bins[i]++
		}
	}
	return bins
}

func peak(bins []int) (int, int) {
	bestI, bestV := 0, 0
	for i, v := range bins {
		if v > bestV {
			bestI, bestV = i, v
		}
	}
	return bestI, bestV
}

func peakFrom(bins []int, fromBin int) (int, int) {
	bestI, bestV := fromBin, 0
	for i := fromBin; i < len(bins); i++ {
		if bins[i] > bestV {
			bestI, bestV = i, bins[i]
		}
	}
	return bestI, bestV
}

func recoveryHits(hits []float64) int {
	n := 0
	for _, t := range hits {
		if t >= outageSec && t < outageSec+1.0 {
			n++
		}
	}
	return n
}

func main() {
	fmt.Println("Sample payment-gateway retry demo: 200 clients, 30s outage")
	fmt.Println("Illustrative simulation only; no real network call.")
	fmt.Println("fixed wait=1s; exp base=1s cap=16s; full jitter seed=42")
	fmt.Println()

	type row struct {
		label string
		s     strategy
		seed  int64
	}
	runs := []row{
		{"A", fixedInterval, jitterSeed},
		{"B", expBackoff, jitterSeed},
		{"C", expBackoffFullJitter, jitterSeed},
	}

	fmt.Printf("%-4s %-36s %8s %12s %14s %12s\n",
		"run", "strategy", "reqs", "peak_t>=1s", "peak_t>=30s", "t=30-31s")
	var allBins [][]int
	var labels []string
	for _, r := range runs {
		hits := simulate(r.s, r.seed)
		bins := histogram(hits)
		_, pAfter0 := peakFrom(bins, 1)
		_, pRec := peakFrom(bins, int(outageSec/binSec))
		fmt.Printf("%-4s %-36s %8d %12d %14d %12d\n",
			r.label,
			r.s.name(),
			len(hits),
			pAfter0,
			pRec,
			recoveryHits(hits),
		)
		allBins = append(allBins, bins)
		labels = append(labels, r.label)
	}

	fmt.Println()
	fmt.Println("Requests per 1s bin (count of attempts starting in that second):")
	fmt.Printf("%-10s %8s %8s %8s\n", "bin", "A_fixed", "B_exp", "C_jitter")
	n := len(allBins[0])
	for i := 0; i < n; i++ {
		a, b, c := allBins[0][i], allBins[1][i], allBins[2][i]
		if a == 0 && b == 0 && c == 0 {
			continue
		}
		fmt.Printf("t=%02.0f-%02.0fs %8d %8d %8d\n",
			float64(i)*binSec, float64(i+1)*binSec, a, b, c)
	}
}
```

```text
Sample payment-gateway retry demo: 200 clients, 30s outage
Illustrative simulation only; no real network call.
fixed wait=1s; exp base=1s cap=16s; full jitter seed=42

run  strategy                                 reqs   peak_t>=1s    peak_t>=30s     t=30-31s
A    fixed interval (1s)                      6200          200            200          200
B    exponential backoff (no jitter)          1200          200            200            0
C    exponential backoff + full jitter        1670          138             26           26

Requests per 1s bin (count of attempts starting in that second):
bin         A_fixed    B_exp C_jitter
t=00-01s      200      200      460
t=01-02s      200      200      138
t=02-03s      200        0       96
t=03-04s      200      200       61
t=04-05s      200        0       68
t=05-06s      200        0       49
t=06-07s      200        0       44
t=07-08s      200      200       30
t=08-09s      200        0       35
t=09-10s      200        0       43
t=10-11s      200        0       21
t=11-12s      200        0       24
t=12-13s      200        0       23
t=13-14s      200        0       15
t=14-15s      200        0       19
t=15-16s      200      200       24
t=16-17s      200        0       24
t=17-18s      200        0       15
t=18-19s      200        0       24
t=19-20s      200        0       30
t=20-21s      200        0       25
t=21-22s      200        0       27
t=22-23s      200        0       24
t=23-24s      200        0       26
t=24-25s      200        0       25
t=25-26s      200        0       16
t=26-27s      200        0       17
t=27-28s      200        0       22
t=28-29s      200        0       27
t=29-30s      200        0       18
t=30-31s      200        0       26
t=31-32s        0      200       20
t=32-33s        0        0       24
t=33-34s        0        0       17
t=34-35s        0        0       18
t=35-36s        0        0       13
t=36-37s        0        0       18
t=37-38s        0        0       22
t=38-39s        0        0        9
t=39-40s        0        0        9
t=40-41s        0        0        5
t=41-42s        0        0       11
t=42-43s        0        0        3
t=43-44s        0        0        4
t=45-46s        0        0        1
```

Nhìn vào kết quả in ra, ở kịch bản A chờ cố định 1 giây, tổng số lượng request sinh ra lên tới 6200 lần. Do không có sự giãn cách, cứ đều đặn mỗi giây lại có đúng 200 lần gọi đập vào hệ thống trong suốt lúc service gặp sự cố. Ngay tại cửa sổ t=30-31s khi server vừa hồi phục, nó lập tức phải hứng trọn 200 request đổ vào cùng một lúc.

Sang kịch bản B dùng exponential backoff không kèm jitter, tổng số lần gọi giảm xuống chỉ còn 1200 request. Tuy nhiên, các lượt gọi vẫn tụ tập thành từng cụm 200 request tại các mốc giây thứ 0, 1, 3, 7 và 15. Ở cửa sổ t=30-31s, số lượng gọi là 0 vì mọi client vẫn đang nằm chờ cho đến giây thứ 31, để rồi tại mốc t=31-32s cả 200 request lại đồng loạt ập vào server.

Ở kịch bản C khi kết hợp exponential backoff với full jitter, tổng số lần gọi ghi nhận được là 1670 request. Anh em để ý ở bin đầu tiên t=00-01s, con số vọt lên 460 vì nó bao gồm 200 lần gọi ban đầu cộng với các lượt retry ngẫu nhiên có thời gian ngủ ngắn rơi vào ngay trong cùng giây đó. Nhưng tính từ sau giây đầu tiên trở đi, đỉnh lưu lượng cao nhất chỉ còn 138 request mỗi giây, và tính từ mốc t>=30s khi server sống lại thì đỉnh cao nhất chỉ là 26 request, riêng tại cửa sổ t=30-31s cũng chỉ có 26 lượt gọi.

Một điểm đáng chú ý trong kịch bản này là phương án C có jitter không tạo ra ít tổng số request hơn phương án B, cụ thể là 1670 lượt so với 1200 lượt. Vì thời gian chờ được lấy ngẫu nhiên từ 0 đến mức trần hiện tại, nhiều client sẽ bốc trúng khoảng ngủ ngắn và thức dậy thử lại thường xuyên hơn. Do đó, chúng ta không nên hiểu nhầm rằng cứ gắn thêm jitter thì tổng lượng gọi trong lúc lỗi sẽ giảm đi.

Khác biệt rõ nhất nằm ở số request dồn vào đúng lúc server vừa hồi phục. Thay vì một cụm 200 request giáng xuống trong cùng một giây ở mốc t=31-32s như phương án B, server ở phương án C chỉ nhận rải rác từng đợt nhỏ với đỉnh 26 request mỗi giây từ sau mốc t=30s, nên service phía sau có khoảng thở để xử lý dần mà không bị sốc tải ngay lúc vừa khởi động.

![Jitter giúp dàn đều request thay vì tập trung vào một thời điểm duy nhất](https://assets.200lab.io/sha256/ee/ee36dae866457658929c66b3b8103f1a0f6546681eb9ea03a315a2dd1316b882/generations/e953cbaf600b6a63a5f76cd36fe2d653a5052cd90908445b2852fa5e261daae6)

## Retry đi cùng idempotency, rate limiting, circuit breaker

Bản thân việc gọi lại chỉ là một mảnh ghép trong bức tranh chịu lỗi của [system design](/blog/system-design-la-gi). Hãy nghĩ xem chuyện gì sẽ xảy ra nếu một request thanh toán đã được xử lý trừ tiền xong, nhưng trên đường trả kết quả về thì network bị đứt gây lỗi timeout. Nếu lúc này client thực hiện retry, khách hàng rất dễ bị trừ tiền hai lần cho cùng một đơn hàng.

Để phòng tránh tai nạn này, các thao tác làm thay đổi dữ liệu hoặc liên quan đến tiền bạc cần có tính chất idempotent, tức là gọi một hay nhiều lần cũng chỉ ra cùng một kết quả. Cách làm phổ biến là phía gọi đính kèm một mã định danh duy nhất cho mỗi giao dịch để phía nhận kiểm tra xem yêu cầu đó đã từng được xử lý hay chưa. Bạn có thể đọc thêm bài viết giải thích về [idempotency key](/blog/idempotency-key-la-gi) trên blog để nắm rõ cách thiết kế mã này.

Ở chiều ngược lại, người viết server không thể giao phó sự ổn định của hệ thống cho ý thức cài đặt backoff từ phía các bên gọi tới. Sẽ có đối tác quên gắn jitter, hoặc gặp lỗi vòng lặp khiến tiến trình của họ bắn phá liên tục vào cổng service của bạn. Lúc này, phía nhận request cần chủ động dựng lớp hạn mức cho từng đối tác thông qua cơ chế [rate limiting](/blog/rate-limiting-la-gi), chẳng hạn đặt ở [API gateway](/blog/api-gateway-la-gi), để bảo vệ tài nguyên.

Ngoài ra, nếu hệ thống phía sau bị hỏng nặng kéo dài hàng chục phút, việc hàng trăm client cứ kiên trì ngủ rồi thức dậy gọi tiếp dù rải rác đến mấy cũng làm lãng phí tài nguyên đôi bên. Đây là lúc cần kết hợp thêm [circuit breaker](/blog/circuit-breaker-la-gi) để chủ động ngắt mạch tạm thời, trả lỗi về ngay lập tức mà không cần gửi request qua network nữa.

![Chỉ retry lỗi tạm thời; thao tác đổi dữ liệu cần idempotency key, lỗi kéo dài cần circuit breaker](https://assets.200lab.io/sha256/14/14f23da286a40b01c8e9b96acfc5c12db0125bb87be93724ce88a32630d0cf44/generations/01870639d846fed82e12926a3ff66c7c32c5ffb6f381556de5af6a29d46b6be7)

## Sai lầm hay gặp khi đặt retry và jitter

Khi đưa cơ chế gọi lại vào dự án, sai lầm dễ gặp đầu tiên là bọc vòng lặp gọi lại bên ngoài mọi lời gọi hàm mà không kiểm tra mã lỗi trả về. Việc gọi lại cả những lỗi 4xx hay lỗi vi phạm rule nghiệp vụ không những vô ích mà còn làm đội thêm độ trễ phản hồi cho người dùng cuối.

Điểm thiếu sót thứ hai là cài đặt hàm tăng thời gian chờ theo cấp số nhân nhưng quên khóa mức trần, hoặc đặt số lần thử lại tối đa quá lớn. Với mức cơ sở 1 giây, nếu hàm mũ cứ nhân đôi mãi sau mỗi lần thất bại, sau 10 lần nhân đôi thời gian chờ đã là 1024 giây (khoảng 17 phút) và sau 12 lần là 4096 giây (hơn 1 giờ), làm các tiến trình đang nằm chờ trở thành gánh nặng chiếm dụng bộ nhớ dù kết nối từ người dùng đã ngắt từ lâu.

Bên cạnh đó, nhiều đội ngũ vẫn để toàn bộ client dùng chung một hàm tính thời gian chờ tĩnh, không có jitter. Lúc chạy thử trên máy với một luồng, mọi thứ trông vẫn trơn tru theo cấp số nhân; hiệu ứng đàn client đập cùng nhịp chỉ lộ khi hàng trăm tiến trình chạy song song.

Khi viết kịch bản test cơ chế retry, bạn đừng chỉ nhìn vào tổng số lần gọi lại trên toàn bộ thời gian chạy, vì như bản demo ở trên, tổng lượt gọi của phương án có jitter đôi khi còn cao hơn phương án không có jitter. Thay vào đó, hãy gom nhóm và đo đạc đỉnh lưu lượng request tính theo từng giây, nhất là ngay tại thời điểm service giả lập vừa mới hồi phục.

Mình chọn exponential backoff kèm full jitter khi nhiều client cùng gọi vào một service có nguy cơ chập chờn, vì ở bản mô phỏng 200 client, cách này kéo đỉnh lưu lượng lúc server vừa hồi phục từ 200 xuống còn 26 request mỗi giây dù tổng lượt gọi là 1670 so với 1200 của backoff thuần. Còn với lỗi 4xx hoặc khi service phía sau sập kéo dài, mình chọn dừng retry ngay hoặc ngắt mạch bằng circuit breaker để không làm tăng tải vô ích.

Nếu bạn muốn tìm hiểu thêm về cách thiết kế hệ thống chịu tải và xử lý các bài toán tương tự trong thực tế, bạn có thể tham khảo qua khóa học ở ngay bên dưới nhé. Khóa này miễn phí, bạn chỉ cần đăng ký và bấm vào học miễn phí để tham gia.

![Thiết kế hệ thống chịu tải cao - rate limiting, load shedding và circuit breaker](https://assets.200lab.io/sha256/98/98f9ab12d1d9bd570c167eb7e82220e0d732a9ff523c6cf522cc384abc38c3de/generations/204dc6125612bbd3a440c9565e0b1f35c837a9fe90431a3fedf55e71c632da16)

- [Thiết kế hệ thống chịu tải cao - rate limiting, load shedding và circuit breaker](https://200lab.io/courses/thiet-ke-he-thong-chiu-tai-cao-rate-limiting-load-shedding-va-circuit-breaker.md)

## Đọc thêm

- [Idempotency key: retry POST không trừ tiền hai lần](/blog/idempotency-key-la-gi) để biết cách chống xử lý trùng giao dịch khi client tự động gọi lại.
- [Circuit breaker là gì](/blog/circuit-breaker-la-gi) để hiểu cách ngắt mạch tạm thời khi service phía sau ngừng hoạt động kéo dài.
- [Rate limiting là gì](/blog/rate-limiting-la-gi) để bảo vệ server trước các đợt retry dồn dập từ phía đối tác.
- [Idempotent Consumer: chống xử lý trùng message](/blog/idempotent-consumer-la-gi) khi áp dụng cơ chế retry cho các hệ thống xử lý bất đồng bộ qua hàng đợi.

## Đọc thêm

- [Distributed lock là gì, vì sao lock Redis vẫn để dữ liệu bị ghi đè](https://200lab.io/blog/distributed-lock-la-gi.md): Distributed lock giúp nhiều instance không chạy trùng một việc. Redis SET NX chặn được chạy cùng lúc, nhưng lock hết hạn giữa chừng thì cần thêm fencing token.
- [Rate limiting là gì? So sánh Fixed Window, Sliding Window, Token Bucket](https://200lab.io/blog/rate-limiting-la-gi.md): Rate limiting kiểm soát tần suất request và trả về mã HTTP 429 khi vượt ngưỡng. Xem so sánh 3 thuật toán cùng cách chọn key và đặt limiter.
- [CRDT là gì? Cách đồng bộ dữ liệu khi nhiều người cùng sửa](https://200lab.io/blog/crdt-la-gi.md): CRDT giúp đồng bộ dữ liệu khi nhiều người cùng chỉnh sửa lúc mất mạng. Các thay đổi được kết hợp ra sao, và xung đột được xử lý thế nào?
- [Composite index là gì? Thứ tự cột và EXPLAIN trên MySQL, PostgreSQL](https://200lab.io/blog/composite-index-la-gi.md): Composite index là gì, vì sao tạo index rồi mà query vẫn Seq Scan? Cùng thử trên PostgreSQL, MySQL để nắm quy tắc đặt cột bằng trước, cột khoảng sau.
- [Transaction là gì, isolation level là gì? Chạy thử trên PostgreSQL, MySQL](https://200lab.io/blog/transaction-isolation-level-la-gi.md): Transaction là gì mà trừ kho vẫn sai? Chạy thử 4 mức isolation level trên PostgreSQL, MySQL để hiểu dirty read, phantom read, MVCC và cách chặn lost update.
- [Mọi bài viết chủ đề Backend](https://200lab.io/blog/tags/backend.md)

Toàn bộ nội dung: https://200lab.io/llms.txt
