Cụm bài Cache: 1. Cache-aside và invalidation · 2. Sự cố cache: avalanche, breakdown, penetration · 3. Review code distributed lock bằng Redis
Bài 1 nói về chuyện cache sai; bài này nói về chuyện cache không đỡ được tải, nên request đổ thẳng xuống DB và DB sập dù code không có bug. Đọc xong, bạn nhận ra sáu sự cố, biết cách chữa và chọn được eviction policy. Nên đọc trước bài 1 (cache-aside, TTL); Redis bên trong (expire, replication, Cluster) ở cụm bài Redis.
1. Cache avalanche: cache sập khi đang tải cao
Ý chính: cache chết đúng lúc tải cao thì DB thiết kế cho 1–5% tải nhận 100% và sập theo. Chữa bằng ba lớp: cache có HA, bảo vệ DB, và phục hồi cache trước khi mở lại traffic.
Nguyên nhân: node chết, sai config, mạng phân mảnh. Pool DB cạn, request timeout, client retry làm tải tăng thêm. Cache sống lại thì rỗng, nên DB vẫn bị dội đến khi cache nạp lại.
flowchart LR
U[10.000 req/s] --> App
App -->|GET| R[(Redis cluster)]
R -.-x|down| App
App ==>|10.000 query/s<br/>thay vì 100| DB[(Database)]
DB -.-> X[connection pool cạn,<br/>timeout, sập]
- Cache có HA (high availability, vẫn chạy khi một node chết): Redis Sentinel (primary + replica, tự failover) hoặc Redis Cluster (shard + replica). Node chết chỉ mất một phần keyspace hoặc vài giây failover.
- Bảo vệ DB: rate limit hoặc bulkhead (vách ngăn: giới hạn query cache-miss đồng thời xuống DB). Circuit breaker quanh lời gọi Redis: đang lỗi thì báo lỗi ngay, không chờ timeout. Phần không quan trọng thì degrade (lỗi nhanh hoặc dữ liệu mặc định).
- Phục hồi cache: bật persistence (RDB snapshot, AOF) để node khởi động lại có sẵn dữ liệu; warm-up (nạp sẵn) key nóng trước khi mở traffic; thêm local cache L1 đỡ phần nóng nhất lúc Redis vắng mặt.
2. Cache avalanche: hàng loạt key hết hạn cùng lúc
Ý chính: không cần cache chết, chỉ cần rất nhiều key hết hạn cùng một giây. Chữa bằng jitter: cộng một độ lệch ngẫu nhiên vào TTL để thời điểm hết hạn trải đều.
Ví dụ: job warm-up nạp 1 triệu key lúc 00:00 với cùng TTL = 3600, nên đúng 01:00 cả triệu key cùng biến mất. Hoặc deploy xoá cache, mọi key nạp lại trong vài phút, rồi hết hạn cùng nhau mãi về sau.
static long ttlWithJitter(long baseSeconds, double jitterRatio) {
long spread = (long) (baseSeconds * jitterRatio);
return baseSeconds + ThreadLocalRandom.current().nextLong(-spread, spread + 1);
}
// ttlWithJitter(600, 0.1) -> [644, 623, 553, 645, 651]: hết hạn rải trong 540–660 giây
Jitter với Spring Cache trên Redis: TtlFunction và bẫy sync = true
Từ Spring Data Redis 3.2, có thể tính TTL theo từng entry bằng TtlFunction:
RedisCacheConfiguration.defaultCacheConfig()
.entryTtl((key, value) -> value == null
? Duration.ofSeconds(30) // entry rỗng: ngắn
: Duration.ofSeconds(600 + ThreadLocalRandom.current().nextLong(-60, 61))); // 10 phút ± 10%
3. Cache breakdown: key nóng hết hạn
Ý chính: chỉ một key, nhưng là key nóng; lúc nó hết hạn, hàng nghìn request cùng miss và cùng chạy query nạp lại. Chữa bằng cách để chỉ một request nạp (mutex, single-flight) hoặc không cho key nóng hết hạn (refresh nền).
Key nóng: trang chủ, sản phẩm flash sale, config. Query 200 ms nhân 2.000 bản là đủ làm DB quá tải. Tên khác: cache stampede, thundering herd (đàn request cùng lao vào một chỗ). Mình đo trên Caffeine với 100 virtual thread cùng miss một key, loader giả lập query 200 ms:
naive check-then-put, 100 threads: DB calls = 100
cache.get(key, loader), 100 threads: DB calls = 1
Bốn cách chữa:
- (a) Không TTL, refresh nền. Key nóng không hết hạn (hoặc TTL rất dài); job định kỳ đọc DB và ghi đè trước khi giá trị cũ, nên không bao giờ miss.
- (b) Mutex: chỉ một request nạp. Request miss thử lấy khoá
SET lock:key token NX PX 3000. Ai lấy được thì đọc DB và nạp; người khác chờ ngắn rồi đọc lại, hoặc trả giá trị cũ (cách viết khoá đúng ở bài 3). - (c) Single-flight trong JVM. Gộp các miss đồng thời trên cùng key trong một instance thành một lần nạp. Caffeine làm sẵn:
cache.get(key, loader)chỉ chạy một loader mỗi key;refreshAfterWritenạp lại bất đồng bộ trong khi vẫn trả giá trị cũ (stale-while-revalidate: trả bản cũ, làm mới ở nền). - (d) Hết hạn sớm theo xác suất (XFetch). Mỗi request tự “tung xúc xắc” để nạp sớm, xác suất tăng dần khi gần hết hạn, nên thường chỉ vài request nạp mà không cần khoá.
flowchart LR
Job[Background job<br/>mỗi 30 giây] -->|đọc| DB[(DB)]
Job -->|SET ghi đè| R[(Redis<br/>key nóng, không TTL)]
App[App: cache-aside] -->|GET| R
App -->|write-around| DB
Tự viết single-flight và công thức XFetch
Single-flight: các thread khác chờ chung một CompletableFuture.
final class SingleFlight<K, V> {
private final ConcurrentHashMap<K, CompletableFuture<V>> inFlight = new ConcurrentHashMap<>();
V load(K key, Supplier<V> loader) {
var mine = new CompletableFuture<V>();
var existing = inFlight.putIfAbsent(key, mine);
if (existing != null) return existing.join(); // có người đang nạp: chờ kết quả đó
try {
V v = loader.get();
mine.complete(v);
return v;
} catch (RuntimeException e) {
mine.completeExceptionally(e); // người chờ cũng nhận lỗi, không treo
throw e;
} finally {
inFlight.remove(key, mine);
}
}
}
// 200 virtual thread cùng miss "product:1" -> loads = 1
XFetch: request nạp lại sớm nếu now − delta × beta × ln(random()) ≥ expiry, với delta là thời gian nạp lần trước. Vì ln(random()) âm, vế trái lớn hơn now một lượng ngẫu nhiên, càng gần expiry càng dễ vượt.
4. Cache penetration: key không tồn tại
Ý chính: request hỏi thứ không có ở cả cache lẫn DB thì cache-aside không bao giờ nạp, nên lần nào cũng đi xuyên xuống DB. Chữa bằng validate, cache giá trị rỗng TTL ngắn, và Bloom filter.
Ví dụ: GET /products/-1, id ngẫu nhiên do bot sinh, sản phẩm đã xoá. Gửi id ngẫu nhiên là đi xuyên qua cache (vì thế gọi là “penetration”).
- Cache giá trị rỗng: DB không thấy thì vẫn ghi một giá trị đặc biệt (
"",0,NullValue) với TTL ngắn (30–60 giây), để không chiếm bộ nhớ lâu và bản ghi tạo sau sớm được thấy. - Validate request: từ chối id sai định dạng, âm, vượt khoảng, chữ ký không hợp lệ ngay ở API, trước khi chạm cache.
- Bloom filter: cấu trúc xác suất (mảng bit + k hàm băm) trả lời “chắc chắn không có” hoặc “có thể có”. Không có false negative, có false positive theo tỉ lệ chọn trước. Đặt trước cache: “chắc chắn không có” thì trả 404 luôn. 1 triệu id với 1% false positive chỉ tốn ~1,14 MB.
Tính kích thước Bloom filter và số đo thực tế
Với n phần tử và tỉ lệ false positive p: số bit m = −n·ln p / (ln 2)², số hàm băm k = (m/n)·ln 2. Mình cài một Bloom filter đơn giản bằng BitSet với 1 triệu id và p = 1%, rồi thử 1 triệu id không tồn tại:
bloom m=9585059 bits (1.14 MB), k=7, false positive rate=0.0101, no false negatives=true
1,14 MB cho 1 triệu id: rẻ hơn nhiều so với cache 1 triệu key rỗng. Trên Redis, module RedisBloom (BF.RESERVE, BF.ADD, BF.EXISTS) có sẵn trong Redis Stack và Redis 8; trong JVM có Guava BloomFilter. Một chỗ áp dụng điển hình: chặn bot quét mã ngẫu nhiên trong Thiết kế URL shortener, với Bloom filter chứa mọi mã đã cấp.
5. Hot key: vài key dồn vào một node
Ý chính: Redis Cluster đặt mỗi key trên đúng một node, nên key nóng làm một node quá tải trong khi node khác rảnh, và thêm node không giúp. Chữa bằng local cache TTL ngắn hoặc nhân bản key.
Cluster chia key vào 16.384 slot (CRC16(key) mod 16384), mỗi slot trên một node. product:34 và product:88 nhận 80% traffic và cùng ở node 1 thì node 1 quá tải.
flowchart LR
App -->|80% traffic| N1[Node 1<br/>product:34, product:88]
App -->|10%| N2[Node 2]
App -->|10%| N3[Node 3]
- Nhân bản key nóng: lưu
product:34#1…product:34#N(suffix khác nhau rơi vào slot khác nhau); client đọc một suffix ngẫu nhiên. Đổi lại, invalidate phải xoá cả N bản. - Local cache: giữ key nóng trong Caffeine ở từng instance, TTL 1–5 giây: Redis chỉ nhận vài request/giây mỗi pod cho key đó.
Đọc từ replica, cách phát hiện hot key, client-side caching của Redis 6
- Đọc từ replica:
ReadFrom.REPLICA_PREFERREDtrong Lettuce. Cấu hình mẫu của khoá học chọnReadFrom.UPSTREAM(chỉ đọc primary) để tránh dữ liệu trễ, đổi lại không trải được tải đọc.
Phát hiện: redis-cli --hotkeys (cần policy LFU) hoặc metric phía client theo key; tránh MONITOR trên production.
6. Big key: value quá to
Ý chính: một value vài MB làm chậm chính nó và mọi lệnh khác, vì Redis chạy lệnh trên một thread. Chữa bằng chia nhỏ, nén, hoặc đưa dữ liệu lớn sang kho khác.
Đa số value 1–2 KB, nhưng product:34 chứa 5 MB (review nhúng thẳng vào JSON). Hậu quả:
- Timeout: đọc 5 MB mất hàng chục ms, lệnh khác xếp hàng sau nó.
- Băng thông: 1.000 đọc/giây × 5 MB = 5 GB/s, vượt card mạng.
- Sửa một phần là ghi lại cả value: thêm một review là gửi lại 5 MB.
- Nạp lại chậm khi bị evict hoặc hết hạn.
Cách chữa: chia nhỏ (hash field theo phần, hoặc product:34:reviews:page:1), nén (gzip, zstd, Snappy), và chọn đúng kho: file lớn để ở object storage (S3) hoặc CDN, cache chỉ giữ đường dẫn.
Chữa thêm, cách tìm big key và bảng tổng hợp sáu sự cố
- TTL dài hơn để ít phải nạp lại.
- Giới hạn big key: review code, cảnh báo khi value vượt ngưỡng (ví dụ 100 KB).
- Tìm big key:
redis-cli --bigkeys(theo số phần tử) và--memkeys(theo bộ nhớ, dùngMEMORY USAGE); cả hai dùngSCANnên an toàn hơnKEYS.
Bảng tổng hợp sáu sự cố:
| Sự cố | Điều gì xảy ra | Cách chữa chính |
|---|---|---|
| Avalanche (cache sập) | cả cluster cache chết khi đang tải cao | HA cluster, circuit breaker, rate limit, warm-up |
| Avalanche (hết hạn đồng loạt) | rất nhiều key hết hạn cùng lúc | TTL + jitter |
| Breakdown | một key nóng hết hạn, hàng nghìn request cùng miss | không hết hạn + refresh nền, mutex, single-flight |
| Penetration | key không có trong cache lẫn DB | cache giá trị rỗng, validate, Bloom filter |
| Hot key | vài key nhận phần lớn traffic, dồn vào một node | nhân bản key, local cache |
| Big key | value vài MB làm timeout và nghẽn mạng | nén, chia nhỏ, chọn kho khác |
7. Hết bộ nhớ: chính sách thay thế
Ý chính: khi đạt maxmemory, Redis làm theo maxmemory-policy; mặc định noeviction từ chối ghi. Redis dùng thuần làm cache thì chọn allkeys-lru hoặc allkeys-lfu.
| Policy | Hành vi |
|---|---|
noeviction (mặc định) |
từ chối lệnh ghi với lỗi OOM |
allkeys-lru / volatile-lru |
bỏ key ít được dùng gần đây (trong mọi key / chỉ key có TTL) |
allkeys-lfu / volatile-lfu |
bỏ key ít được dùng thường xuyên |
allkeys-random / volatile-random |
bỏ ngẫu nhiên |
volatile-ttl |
bỏ key sắp hết hạn nhất |
- LRU (Least Recently Used, bỏ thứ lâu nhất chưa đọc): hợp khi thứ vừa đọc dễ được đọc tiếp.
- LFU (Least Frequently Used, bỏ thứ ít được đọc nhất): hợp thứ nổi tiếng lâu dài như tweet hot, không bị một lần quét dữ liệu cũ đẩy ra.
- W-TinyLFU (Caffeine): kết hợp hai cái trên, hit rate thường gần tối ưu.
- Allowlist nạp sẵn (flash sale): nạp trước danh sách sản phẩm, không TTL, không bị evict, thay vì hy vọng LRU đoán đúng.
LRU/LFU xấp xỉ của Redis, W-TinyLFU và chỗ đặt allowlist
- Redis làm LRU xấp xỉ: lấy mẫu
maxmemory-samples(mặc định 5) key rồi bỏ cái cũ nhất, không giữ danh sách liên kết toàn cục. - LFU của Redis dùng bộ đếm logarit 8 bit có suy giảm theo thời gian (
lfu-decay-time), để thứ từng nóng không ở mãi. - W-TinyLFU của Caffeine: một cửa sổ LRU nhỏ cho key mới, một vùng chính chia probation/protected, và một bộ đếm tần suất dạng sketch quyết định key mới có được nhận vào hay không. Nhờ vậy một đợt quét không làm trôi key nóng.
- Allowlist nạp sẵn nên để ở instance/DB riêng hoặc local cache, để không bị eviction của cache chung đụng tới.
Bài tập
Bài tập local cache (sân bay với Caffeine) của buổi này nằm ở bài 3, kèm phần review lời giải mẫu.
Bài 1: trang sản phẩm flash sale
Đề (diễn giải): 20h tối nay mở bán 50 sản phẩm, dự kiến 30.000 req/s vào trang chi tiết của chúng, DB chịu tối đa 2.000 query/s. Thiết kế cache để DB không sập.
Lời giải Bài 1: allowlist, local cache, single-flight, bulkhead
- Allowlist nạp sẵn: 19h50 job nạp 50 sản phẩm vào Redis, không TTL; giá/tồn kho hiển thị được job ghi đè mỗi 5 giây (refresh nền), nên không bao giờ có breakdown.
- Hot key: 50 key × 30.000 req/s dồn vào vài node; thêm local cache Caffeine TTL 2 giây ở từng pod. 40 pod × 50 key × 0,5 lần/giây = 1.000 lượt đọc Redis mỗi giây, thay vì 30.000.
- Stampede:
cache.get(key, loader)trong Caffeine để mỗi pod chỉ một lần nạp mỗi key. - Penetration: validate id thuộc allowlist, id khác trả 404 không chạm DB.
- Avalanche: các trang khác dùng TTL có jitter; bulkhead giới hạn query cache-miss đồng thời xuống DB, ví dụ 50.
- Trừ tồn kho không dựa vào cache:
UPDATE ... WHERE stock > 0hoặcDECRnguyên tử, xem transaction và locking.
Bài 2: tính kích thước Bloom filter
Đề (diễn giải): có 50 triệu user id, muốn chặn id không tồn tại với false positive 0,1%. Bloom filter tốn bao nhiêu bộ nhớ, bao nhiêu hàm băm?
Lời giải Bài 2: ~90 MB, 10 hàm băm
m = −n·ln p / (ln 2)² = 50·10⁶ × 6,908 / 0,4805 ≈ 719 triệu bit ≈ 90 MB; k = (m/n)·ln 2 ≈ 14,4 × 0,693 ≈ 10. Mỗi lần thêm user mới phải BF.ADD; user bị xoá vẫn “có thể có” cho đến lần xây lại định kỳ. So với cache null: 90 MB cố định, chặn được cả 10 triệu id ngẫu nhiên khác nhau.
Ghi nhớ
- Phân biệt được avalanche, breakdown và penetration, và kể được cách chữa chính cho từng cái.
- Giải thích được vì sao cache khởi động lại rỗng có thể làm DB sập lần hai, và quy trình mở lại traffic.
- Biết khi nào chọn refresh nền, mutex, single-flight hay XFetch, và vì sao
@Cacheable(sync = true)không đủ trên nhiều pod. - Giải thích được vì sao thêm node không chữa hot key, và cách chữa.
- Chọn được
maxmemory-policycho Redis thuần cache và biết bẫyvolatile-*với key không TTL.
Câu hỏi phỏng vấn
Mid
Cache avalanche, breakdown và penetration khác nhau thế nào?
Avalanche là nhiều key (hoặc cả cache) mất cùng lúc, breakdown là một key nóng hết hạn, penetration là key không tồn tại ở đâu cả.
Avalanche: cache sập hoặc rất nhiều key hết hạn cùng lúc, tải đổ xuống DB trên diện rộng. Breakdown: một key nóng hết hạn, hàng nghìn request cùng miss và cùng nạp lại. Penetration: key không tồn tại ở cả cache lẫn DB, nên luôn đi xuyên xuống DB. Chữa lần lượt bằng HA + jitter + bảo vệ DB; refresh nền/mutex/single-flight; cache null + validate + Bloom filter.
Bloom filter là gì và dùng ở đâu trong caching?
Cấu trúc xác suất trả lời “chắc chắn không có” hoặc “có thể có”; đặt trước cache để chặn penetration.
Mảng bit cộng k hàm băm. Thêm phần tử thì bật k bit; kiểm tra thì nếu có bit nào tắt là chắc chắn không có, nếu tất cả bật là có thể có. Không có false negative, có false positive theo tỉ lệ chọn trước, không xoá được phần tử. Id chắc chắn không tồn tại trả 404 ngay. 1 triệu id với 1% false positive chỉ tốn khoảng 1,2 MB.
Senior
Một key nóng hết hạn làm DB quá tải. Bạn chọn cách chữa nào?
Single-flight trong JVM luôn bật, cộng refresh nền hoặc mutex theo key trên Redis cho vài key thật sự nóng.
Single-flight (Caffeine get(key, loader)) chỉ gộp trong một pod. Với vài key thật sự nóng: không TTL và refresh nền, hoặc stale-while-revalidate (refreshAfterWrite) để request không bao giờ chờ. Khi cần chặn trên toàn cluster: mutex theo key trên Redis (SET NX PX + token), request khác trả giá trị cũ hoặc chờ ngắn. XFetch nếu muốn không khoá. Kèm bulkhead giới hạn số query nạp lại đồng thời xuống DB.
Cache null để chống penetration có nhược điểm gì?
Tốn một key cho mỗi id rác và có thể báo sai “không có” đến hết TTL.
Kẻ tấn công dùng id ngẫu nhiên có thể làm đầy bộ nhớ, và id đầu tiên mỗi loại vẫn xuống DB. TTL phải ngắn, nếu không bản ghi được tạo sau sẽ bị báo “không có” đến hết TTL. Với Spring, disableCachingNullValues() cộng unless = "#result == null" lại tắt hẳn cơ chế này. Kết hợp với validate và Bloom filter.
Hot key trên Redis Cluster: vì sao thêm node không giúp và bạn làm gì?
Một key thuộc một slot, một slot nằm trên một node, nên traffic của key vẫn vào một node; chữa bằng local cache hoặc nhân bản key.
Cách chữa: local cache TTL ngắn ở từng instance (hoặc client-side caching của Redis 6 với invalidation), nhân bản key thành N bản có suffix trải trên nhiều slot (phải xoá cả N khi invalidate), hoặc đọc từ replica nếu chấp nhận dữ liệu trễ. Phát hiện bằng --hotkeys với policy LFU hoặc metric phía client.
Big key gây vấn đề gì và xử lý thế nào?
Value vài MB chặn thread lệnh duy nhất của Redis và ngốn băng thông; xử lý bằng chia nhỏ, nén, chuyển kho, xoá bằng UNLINK.
Lệnh chậm và chặn các lệnh khác, sửa một phần phải ghi lại cả value, nạp lại chậm. Xử lý: nén, chia thành nhiều key hoặc hash field, TTL dài hơn, giới hạn kích thước trong review và cảnh báo, chuyển file lớn sang object storage. Tìm bằng --bigkeys/--memkeys; xoá bằng UNLINK thay vì DEL.
LRU, LFU, W-TinyLFU khác nhau thế nào, và Redis chọn policy nào?
LRU theo độ gần, LFU theo tần suất, W-TinyLFU kết hợp hai cái; Redis thuần cache chọn allkeys-lru hoặc allkeys-lfu.
LRU bỏ key lâu nhất chưa được đọc, nhưng một đợt quét có thể đẩy key nóng ra. LFU bỏ key ít được đọc nhất, cần suy giảm bộ đếm để thứ từng nóng không ở mãi. W-TinyLFU (Caffeine): cửa sổ LRU nhỏ cho key mới, bộ đếm tần suất quyết định có nhận key mới vào vùng chính hay không. Redis dùng LRU/LFU xấp xỉ theo mẫu; noeviction mặc định chỉ hợp khi Redis là kho dữ liệu.
Redis cache cluster chết lúc cao điểm. Hệ thống của bạn nên hành xử thế nào?
Lỗi phải đến nhanh và DB phải được che bằng bulkhead; khi Redis sống lại thì warm-up trước, mở traffic dần.
Timeout client ngắn, circuit breaker mở, không treo thread. Đường cache-miss xuống DB đi qua bulkhead hoặc rate limit, phần vượt quá trả lỗi nhanh hoặc dữ liệu degrade (danh sách rỗng, giá trị mặc định) cho tính năng không quan trọng. Local cache L1 đỡ phần nóng nhất. Khi Redis phục hồi: nạp lại từ persistence hoặc warm-up key nóng trước, mở traffic dần. Về lâu dài: Sentinel/Cluster có replica, và load test kịch bản “Redis chết” để biết DB chịu được bao nhiêu.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu tiếng Anh dùng trong phỏng vấn |
|---|---|---|---|
| cache avalanche | /kæʃ ˈævəlɑːnʃ/ | cache sập hoặc nhiều key hết hạn cùng lúc | “A warm-up job with a fixed TTL caused a cache avalanche every hour.” |
| cache stampede | /kæʃ stæmˈpiːd/ | nhiều request cùng nạp lại một key | “Single-flight loading turned a stampede of 200 loads into one.” |
| thundering herd | /ˈθʌndərɪŋ hɜːd/ | đàn request cùng lao vào một tài nguyên | “Leases protect the database from a thundering herd on hot keys.” |
| cache penetration | /kæʃ ˌpenɪˈtreɪʃn/ | request cho key không tồn tại xuyên xuống DB | “Random ids from a bot were a classic cache penetration attack.” |
| jitter | /ˈdʒɪtə/ | độ lệch ngẫu nhiên | “We add ten percent jitter to every TTL so keys don’t expire together.” |
| Bloom filter | /bluːm ˈfɪltə/ | cấu trúc xác suất kiểm tra thành viên | “A Bloom filter tells us an id definitely doesn’t exist.” |
| false positive | /fɔːls ˈpɒzətɪv/ | báo có trong khi không có | “At one percent false positives, the filter needs about ten bits per id.” |
| hot key | /hɒt kiː/ | key nhận rất nhiều traffic | “Adding nodes didn’t help, because a hot key lives on a single node.” |
| eviction policy | /ɪˈvɪkʃn ˈpɒləsi/ | chính sách loại bỏ khi đầy bộ nhớ | “For a pure cache we use allkeys-lfu as the eviction policy.” |
| bulkhead | /ˈbʌlkhed/ | vách ngăn giới hạn tài nguyên | “A bulkhead caps concurrent cache-miss queries to the database.” |
Ghi chép dựa trên khoá Advanced Backend (Ronin Engineer), viết lại theo cách hiểu của mình.