Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

System DesignMid21 phút đọc

Cache-aside, write-around và bài toán lệch dữ liệu cache–DB

Ôn 19 thẻ
Trong bài này

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, @Cacheable củ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.sleep trong request.
  • Version + tombstone: mỗi dòng có cột version tă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à DELETE trong 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ới UPDATE; 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 @Transactional là 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.