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
Redis có thể đưa API từ 80 ms xuống 5 ms, và mang theo bug mới: sửa tuổi 33 thành 34, F5 vẫn thấy 33, mười phút sau mới đúng. Bài này trả lời: khi dữ liệu thay đổi, làm sao để cache không nói dối, và nếu có thì tối đa bao lâu. Nên đọc trước Transaction, isolation level và locking vì phần lớn bài là phân tích race condition; cách Redis lưu dữ liệu, xoá key hết hạn, persistence, replication và Cluster nằm ở cụm bài Redis.
1. Cache là gì và đo bằng gì
Ý chính: cache giữ tạm dữ liệu để đọc lại nhanh hơn, chỉ đáng tiền với dữ liệu nóng. Thước đo chính là hit rate (tỉ lệ lượt đọc trúng cache).
Trong cache là bản sao dữ liệu nguồn (một dòng customer) hoặc kết quả tính (tổng đơn hôm nay, trang search). Cache là tấm khiên của database: DB đắt và khó scale ngang, cache hấp thụ phần lớn lượt đọc. Giá phải trả: hiệu năng vs chi phí và hiệu năng vs nhất quán.
Dữ liệu nóng là phần nhỏ dữ liệu nhận phần lớn lượt đọc (80/20). Với hit rate h:
latency trung bình ≈ t_cache + (1 − h) × t_db
tải xuống DB = (1 − h) × tổng lượt đọc
Ví dụ t_cache = 1 ms, t_db = 20 ms, 10.000 req/s:
| Hit rate | Latency trung bình | Query/s xuống DB |
|---|---|---|
| 95% | 2 ms | 500 |
| 99% | 1,2 ms | 100 |
Latency gần như không đổi, nhưng tải DB giảm 5 lần. Nên khi hit rate tụt (deploy đổi format key, xoá nhầm cả cache), DB chết trước.
2. Cache nằm ở đâu
Ý chính: cùng một dữ liệu có thể nằm cùng lúc ở bốn lớp (client, CDN/proxy, app, Redis), mỗi lớp hết hạn theo cách riêng. Đây là một nửa lý do invalidation khó.
flowchart LR
C[Client<br/>cache response] --> CDN[CDN<br/>html, js, css, media]
C --> P[Reverse proxy<br/>file tĩnh]
CDN --> S
P --> S[App server<br/>local cache: config,<br/>danh mục nhỏ]
S --> R[Remote cache Redis<br/>kết quả query, kết quả tính,<br/>dữ liệu dùng chung]
S --> DB[(Database<br/>buffer pool)]
R -. miss .-> DB
HTTP cache phía client thì không ai xoá được. MySQL bỏ query cache từ 8.0 cũng vì invalidation: mỗi lần ghi bảng phải xoá mọi kết quả liên quan dưới một mutex toàn cục.
3. Chiến lược đọc
Ý chính: read-through để thư viện cache tự nạp khi miss; cache-aside để app tự làm cả năm bước. Cache-aside phổ biến nhất với Redis.
Trước khi hỏi “lưu thế nào”, hỏi “dữ liệu được truy cập thế nào”: đọc hay ghi.
- Read-through: app chỉ nói chuyện với cache; khi miss, thư viện cache gọi loader đọc DB rồi lưu (Caffeine
LoadingCache,@Cacheablecủa Spring nhìn từ phía app). - Cache-aside (read-aside): app tự đọc cache, miss thì đọc DB rồi ghi vào cache.
sequenceDiagram
participant A as App
participant C as Cache
participant D as DB
A->>C: 1. GET key
C-->>A: 2a. hit: trả value
A->>D: 2b. miss: SELECT
D-->>A: 3. row
A->>C: 4. SET key value EX ttl
A-->>A: 5. trả kết quả
Cache-aside chịu được Redis hỏng (thì đọc DB, nếu client có timeout ngắn) và cache được mọi hình dạng dữ liệu (DTO đã join 3 bảng). Đổi lại, logic nằm trong app và có cửa sổ lệch dữ liệu giữa lúc đọc DB và lúc ghi cache (mục 6).
Code cache-aside với Spring Boot 3 và bẫy timeout của Redis client
Tự bắt lỗi cache để “chịu được cache hỏng” là thật:
@Service
class CustomerQueryService {
private static final Duration TTL = Duration.ofMinutes(10);
private final StringRedisTemplate redis;
private final CustomerStore store;
private final ObjectMapper json;
static String key(long id) { return "customer:v1:" + id; }
public CustomerView get(long id) {
String key = key(id);
String cached = readCache(key); // 1. đọc cache
if (cached != null) return fromJson(cached); // 2. hit
CustomerView view = store.findView(id) // 3. miss -> DB
.orElseThrow(() -> new NoSuchElementException("customer " + id));
writeCache(key, toJson(view)); // 4. nạp lại kèm TTL
return view;
}
private String readCache(String key) {
try {
return redis.opsForValue().get(key);
} catch (DataAccessException e) { // Redis chết/timeout: rơi về DB
log.warn("cache read failed for {}: {}", key, e.getMessage());
return null;
}
}
// writeCache: set(key, value, TTL) trong try/catch tương tự; toJson/fromJson dùng ObjectMapper
}
Key có version (v1) để đổi cấu trúc DTO chỉ cần chuyển sang v2; value là JSON thay vì JDK serialization.
4. Chiến lược ghi
Ý chính: ghi cache cùng lúc với DB (write-through), ghi cache rồi flush DB sau (write-back), hoặc ghi DB rồi xoá cache (write-around). Với dữ liệu nghiệp vụ, write-around + cache-aside là mặc định hợp lý.
- Write-back trả về ngay, flush DB sau theo lô; tên mượn từ CPU (ghi vào cache rồi mới đẩy xuống RAM).
- Write-around tách rời cache và DB, thường xoá cache bất đồng bộ; dữ liệu vừa ghi nhiều vừa đọc nhiều sẽ miss liên tục.
5. Vấn đề chung: lệch dữ liệu và invalidation
Ý chính: mọi chiến lược đều có lúc cache nói Age=26 khi DB đã là 27. Cách chữa là cache invalidation (loại bỏ dữ liệu không còn đúng); nó khó vì thời điểm, đồng thời, quan hệ dữ liệu và cache nằm khắp nơi.
Bốn kiểu invalidation:
- Time-based: TTL (time to live, thời gian sống của key), tự hết hạn.
- Command-based: ghi xong thì app update hoặc delete key.
- Event-based: nghe sự kiện thay đổi (event, CDC) rồi xoá.
- Group-based: xoá cả nhóm theo tag hoặc prefix.
Ngoài thời điểm (TTL bao lâu?) và race, còn quan hệ dữ liệu (một product nằm trong key chi tiết, trang danh sách, kết quả search) và khó tìm nguyên nhân: lỗi phụ thuộc thứ tự thời gian rồi tự hết sau TTL.
Xoá theo nhóm: KEYS, SCAN, tag set và namespace có version
6. Case study: ba lần thử sửa lệch dữ liệu
Ý chính: update cache thì hai writer làm lệch; delete thì không. Với reader, “xoá trước” lệch thường xuyên, còn “commit DB rồi xoá” chỉ lệch trong một race rất hiếm, nên đó là đáp án.
Phía đọc là cache-aside; phía ghi là write-around, chọn update (ghi giá trị mới vào cache) hay delete (xoá key). Mọi sơ đồ dưới khớp với một chương trình nhỏ phát lại từng thứ tự xen kẽ (interleaving) trên “DB” và “cache” bằng HashMap.
Lần thử 1: update cache, trước hay sau DB?
sequenceDiagram
participant W1 as Request 1 (age=1)
participant C as Cache
participant D as DB
participant W2 as Request 2 (age=2)
Note over W1,W2: Update cache trước
W1->>C: SET age=1
W2->>C: SET age=2
W2->>D: UPDATE age=2
W1->>D: UPDATE age=1
Note over C,D: cache=2, DB=1 → DB sai
Note over W1,W2: Update cache sau
W1->>D: UPDATE age=1
W2->>D: UPDATE age=2
W2->>C: SET age=2
W1->>C: SET age=1
Note over C,D: DB=2, cache=1 → cache sai đến hết TTL
Lần thử 2: delete cache
Hai writer ghi DB rồi xoá key, thứ tự nào cũng đúng: row lock tuần tự hoá hai UPDATE, cache rỗng, lần đọc sau nạp lại. Delete idempotent (làm hai lần như một) và không mang giá trị. Nhưng reader cũng ghi vào cache (bước 4), nên lần thử 3 xét writer đấu reader với combo RA + DWA (Read-Aside + Delete-Write-Around).
Lần thử 3: RA + DWA, writer đấu với reader
Xoá cache trước, rồi update DB:
sequenceDiagram
participant W as Writer (age 0→1)
participant C as Cache
participant D as DB
participant R as Reader
W->>C: DEL age
R->>C: GET age (miss)
R->>D: SELECT age → 0
R->>C: SET age=0
W->>D: UPDATE age=1
Note over C,D: cache=0 (cũ), DB=1 — cũ đến hết TTL
Cửa sổ rộng: cả câu UPDATE và transaction quanh nó.
Update DB trước, rồi xoá cache:
sequenceDiagram
participant R as Reader
participant D as DB
participant C as Cache
participant W as Writer (age 0→1)
R->>C: GET age (miss)
R->>D: SELECT age → 0
W->>D: UPDATE age=1 (commit)
W->>C: DEL age
R->>C: SET age=0
Note over D,C: DB=1, cache=0 — vẫn lệch
Vẫn lệch, nhưng cần đủ ba điều kiện: key đang không có trong cache, reader đọc DB trước khi writer commit, và writer làm xong UPDATE + commit + DEL lọt giữa lúc reader đọc DB và lúc reader SET. Khe đó chỉ là một round-trip Redis (dưới 1 ms), còn một lần ghi có commit (fsync redo log/WAL) lâu hơn nhiều, nên rất hiếm.
Đáp án
Update DB trước, xoá cache sau, kèm TTL ngắn vừa phải làm lưới an toàn cho race hiếm đó hoặc lần xoá bị lỗi.
Code xoá cache sau commit với Spring
Phía ghi publish event, việc xoá chạy sau commit:
@Transactional
public void changeAge(long id, int age) {
store.updateAge(id, age);
events.publishEvent(new CustomerChanged(id)); // chỉ được giao sau COMMIT
}
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
void onChanged(CustomerChanged event) {
String key = CustomerQueryService.key(event.id());
try {
redis.delete(key);
} catch (DataAccessException e) {
retryQueue.enqueue(key); // thử lại bất đồng bộ, có backoff
}
}
7. Vượt slide: đóng nốt khe hở còn lại
Ý chính: ba cách đóng race “reader chậm nạp lại bản cũ”: double delete chỉ thu hẹp cửa sổ; version + tombstone và lease từ chối bản cũ một cách xác định.
- Delayed double delete: xoá ngay sau commit, rồi xoá lần nữa sau khoảng trễ lớn hơn một lần đọc DB cộng replication lag (vài trăm ms đến vài giây). Chạy lần hai qua delay queue hoặc job, không
Thread.sleeptrong request. - Version + tombstone: mỗi dòng có cột
versiontăng mỗi lần ghi. Thay vìDEL, writer ghi tombstone (dấu “đã xoá”) “vô hiệu ở version N” có TTL ngắn; reader chỉ được nạp nếu version nó đọc không cũ hơn. - Lease (paper “Scaling Memcache at Facebook”): khi miss, memcache cấp lease token; chỉ
SETđược kèm token, vàDELETEtrong lúc ấy huỷ token. Redis không có lease sẵn; tombstone + version là cách mô phỏng gần nhất.
Lua cho version + tombstone, kết quả chạy và chi tiết lease
Điều kiện và ghi phải nguyên tử, nên dùng Lua:
-- populate: KEYS[1]=key ARGV[1]=version ARGV[2]=payload ARGV[3]=ttlMs
local cur = redis.call('HGET', KEYS[1], 'v')
if cur and tonumber(cur) > tonumber(ARGV[1]) then return 0 end
if cur and tonumber(cur) == tonumber(ARGV[1]) and redis.call('HEXISTS', KEYS[1], 'data') == 1 then return 0 end
redis.call('HSET', KEYS[1], 'v', ARGV[1], 'data', ARGV[2])
redis.call('PEXPIRE', KEYS[1], ARGV[3])
return 1
-- invalidate (newVersion): nếu version hiện có nhỏ hơn thì DEL key, HSET v=newVersion, PEXPIRE ngắn
Chạy với Redis 7, reader chậm đọc version 7, writer nâng lên 8:
writer invalidate(v8) -> 1
stale reader populate(v7) -> 0 (0 = rejected)
fresh reader populate(v8) -> 1 {v=8, data={"age":34}}
Lease của memcache còn giới hạn tần suất cấp token cho mỗi key, nên chặn luôn thundering herd (cả đàn request cùng lao xuống DB) khi key nóng hết hạn (bài 2).
8. Sự cố 01: không có tính nguyên tử giữa DB và cache
Ý chính: UPDATE thành công nhưng DEL trên Redis lỗi thì cache giữ bản cũ đến hết TTL. Phải làm cho việc xoá được thử lại đến khi xong: retry, outbox hoặc CDC.
Khách hàng X sửa tuổi 33 → 34 rồi phàn nàn “phải một lúc sau mới thấy”, dù hệ thống làm đúng thứ tự. DEL đã thất bại (timeout, Redis đang failover, pod bị kill giữa chừng).
- Retry: đồng bộ có backoff, hoặc qua queue.
- Outbox: ghi dòng
cache_invalidation(key)trong cùng transaction vớiUPDATE; job đọc outbox rồi xoá key. - CDC (change data capture, đọc log thay đổi của DB qua binlog/WAL): Debezium, Canal hoặc consumer tự viết xoá key, kể cả thay đổi từ script hay admin sửa tay.
flowchart LR
App[App] -->|UPDATE customer| DB[(DB)]
DB -->|binlog / WAL| CDC[CDC connector<br/>Debezium]
CDC -->|change event| K[[Kafka topic]]
K --> Inv[Invalidator]
Inv -->|DEL customer:v1:42<br/>retry đến khi được| R[(Redis)]
App -->|cache-aside read| R
Vận hành CDC: replication slot của PostgreSQL và binlog của MySQL
Bài tập
Bài 1: chọn chiến lược cho từng loại dữ liệu
Đề (diễn giải): sàn thương mại điện tử có (a) danh sách tỉnh/thành, (b) chi tiết sản phẩm (giá đổi vài lần một ngày), (c) lượt xem sản phẩm, (d) số dư ví. Chọn chiến lược và TTL.
Lời giải Bài 1
| Dữ liệu | Chiến lược | TTL |
|---|---|---|
| Tỉnh/thành | local cache (Caffeine), nạp lúc khởi động | vài giờ |
| Chi tiết sản phẩm | cache-aside + delete sau commit, CDC nếu nhiều đường ghi | 5–15 phút, có jitter |
| Lượt xem | write-back: INCR trên Redis, job flush xuống DB mỗi phút |
không |
| Số dư ví | không dùng cache để quyết định; chỉ hiển thị với TTL rất ngắn | 0–5 giây |
Bài 2: tìm race trong đoạn code
Đề (diễn giải): đoạn code sau thỉnh thoảng làm trang sản phẩm hiển thị giá cũ hàng giờ. Tìm nguyên nhân và sửa.
@Transactional
public void updatePrice(long id, BigDecimal price) {
redis.delete("product:" + id);
productRepository.updatePrice(id, price);
auditService.record(id, price); // gọi HTTP sang service khác, ~300 ms
}
// key product:* được set không kèm TTL
Lời giải Bài 2
Ba lỗi cộng hưởng:
- Xoá trước khi ghi DB, lại còn trước commit, nên cửa sổ lệch kéo dài suốt transaction, gồm cả lời gọi HTTP 300 ms; reader nào miss trong đó nạp giá cũ.
- Key không có TTL nên giá cũ sống đến lần sửa giá tiếp theo.
- Lời gọi audit nằm trong transaction làm transaction dài ra.
Sửa: ghi DB, publish event, xoá ở AFTER_COMMIT có retry, đặt TTL cho mọi key, và đưa lời gọi audit ra khỏi transaction (hoặc qua outbox).
Ghi nhớ
- Tính được tải DB giảm bao nhiêu khi hit rate tăng từ 95% lên 99%.
- Giải thích được vì sao writer nên xoá key thay vì ghi giá trị mới.
- Vẽ được race “xoá trước” và race “commit trước, xoá sau”, và vì sao cái sau hiếm.
- Biết vì sao xoá trong
@Transactionallà sai và cách đưa nó ra sau commit. - So sánh được retry, outbox, CDC; và double delete, version + tombstone, lease.
Câu hỏi phỏng vấn
Junior
Cache-aside hoạt động thế nào?
App đọc cache trước; miss thì đọc DB, ghi vào cache kèm TTL rồi trả về.
Phía ghi thường là write-around: ghi DB rồi xoá key. Ưu: Redis hỏng vẫn đọc được DB, cache lưu được dạng khác bảng. Nhược: logic nằm trong app và có cửa sổ dữ liệu cũ.
Cache hit rate là gì và vì sao quan trọng?
Tỉ lệ lượt đọc được cache phục vụ; nó quyết định tải xuống DB.
Tải DB bằng (1 − hit rate) × lượt đọc, nên từ 95% lên 99% giảm 5 lần tải DB. Hit rate cao khi dữ liệu có phân bố nóng (80/20). Hit rate tụt sau deploy thường là dấu hiệu đổi format key hoặc xoá nhầm cả cache.
Mid
Khi dữ liệu thay đổi, nên update hay delete key trong cache? Vì sao?
Delete, vì ghi giá trị từ phía writer có race giữa hai writer, còn delete thì đổi chỗ vẫn đúng.
A ghi DB, B ghi DB, B set cache, A set cache: cache giữ giá trị của A trong khi DB là của B. Delete không mang giá trị và idempotent; lần đọc sau nạp lại từ DB. Delete còn tránh tốn công tính giá trị cho key có thể không ai đọc.
Ghi DB trước rồi xoá cache, hay xoá cache trước? Vì sao?
Ghi DB (commit) trước, xoá sau, kèm TTL; “sau” nghĩa là sau commit, không phải sau câu UPDATE trong transaction.
Xoá trước thì reader miss trong lúc DB đang ghi sẽ nạp giá trị cũ, cửa sổ bằng cả thời gian ghi. Ghi trước thì chỉ lệch khi một lần ghi DB hoàn chỉnh lọt vào khe rất nhỏ giữa lúc reader đọc DB và lúc reader set cache, rất hiếm vì thao tác cache nhanh hơn nhiều. TTL chặn trên trường hợp xấu.
Write-through, write-back và write-around khác nhau thế nào?
Khác ở chỗ ghi vào đâu trước và lúc nào trả về.
- Write-through ghi cache và DB đồng bộ rồi mới trả về: cache luôn mới, ghi chậm hơn.
- Write-back ghi cache rồi trả về, flush DB sau: rất nhanh nhưng mất dữ liệu nếu cache chết, hợp cho counter.
- Write-around ghi DB rồi vô hiệu hoá cache: cache chỉ chứa thứ được đọc, nhưng dữ liệu ghi nhiều đọc nhiều sẽ miss liên tục.
Senior
Ghi DB thành công nhưng xoá cache thất bại. Bạn đảm bảo invalidation thế nào?
DB và cache không có transaction chung, nên làm cho việc xoá được thử lại đến khi thành công, và luôn có TTL làm chặn trên.
- Retry có backoff trong app (mất nếu process chết).
- Outbox ghi “ý định xoá” trong cùng transaction rồi job xoá.
- CDC đọc binlog/WAL và xoá key, bắt cả thay đổi ngoài app.
Với Postgres giám sát replication slot; với MySQL cần binlog_format=ROW và giữ binlog đủ lâu.
Đã ghi DB trước rồi xoá sau commit mà vẫn thấy dữ liệu cũ kéo dài. Bạn nghi ngờ gì?
Nghi đầu tiên là nạp cache từ replica đang trễ, rồi đến lần xoá lỗi im lặng và các lớp cache khác.
(1) Nạp cache từ read replica đang trễ. (2) Xoá thất bại im lặng (bắt exception rồi bỏ qua). (3) Còn lớp cache khác: local cache từng pod, CDN, HTTP cache của client. (4) Key phái sinh chưa được xoá. (5) Key không có TTL. Kiểm tra bằng metric invalidation, TTL key, và so thời điểm commit với thời điểm SET cuối của key.
Làm sao đóng hẳn race “reader chậm nạp giá trị cũ sau khi writer đã xoá”?
Muốn đóng hẳn thì dùng version + tombstone hoặc lease; double delete chỉ thu hẹp cửa sổ.
- Delayed double delete: xoá lần hai sau khoảng trễ lớn hơn thời gian đọc DB cộng replication lag.
- Version + tombstone bằng Lua: chỉ cho nạp nếu version đọc từ DB không cũ hơn version đã vô hiệu (xác định, cần cột version).
- Lease như memcache của Facebook: set bị từ chối nếu có delete sau khi lease được cấp, đồng thời chặn thundering herd.
Dữ liệu không được phép cũ dù một lần thì không dùng cache cho quyết định đó.
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-aside | /kæʃ əˈsaɪd/ | app tự đọc cache, miss thì đọc DB rồi nạp | “We use cache-aside, so the application decides what goes into Redis.” |
| write-around | /raɪt əˈraʊnd/ | ghi thẳng DB, vô hiệu hoá cache | “Writes go around the cache: we update the database and delete the key.” |
| hit rate | /hɪt reɪt/ | tỉ lệ đọc trúng cache | “Going from 95 to 99 percent hit rate cut database load fivefold.” |
| invalidation | /ɪnˌvælɪˈdeɪʃn/ | vô hiệu hoá dữ liệu cache | “Invalidation runs after commit, never inside the transaction.” |
| interleaving | /ˌɪntəˈliːvɪŋ/ | cách các bước của nhiều request đan xen | “In this interleaving the reader sets the cache after the delete.” |
| tombstone | /ˈtuːmstəʊn/ | bản ghi đánh dấu đã xoá | “The writer leaves a tombstone with the new version instead of a plain delete.” |
| change data capture | /tʃeɪndʒ ˈdeɪtə ˈkæptʃə/ | bắt thay đổi từ log của DB | “CDC from the binlog catches changes made outside the application too.” |
| replication lag | /ˌreplɪˈkeɪʃn læɡ/ | độ trễ của replica | “Reading from a lagging replica on a miss repopulated the old value.” |
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.