Có một lần cache của mình hết hạn đúng lúc traffic cao. Một key "sản phẩm hot" chết, và trong vài trăm mili-giây tiếp theo, 400 request cùng thấy cache miss, cùng chạy một câu query nặng vào database. DB tăng CPU lên 100%, query chậm lại, càng chậm thì càng nhiều request chồng lên. Hiện tượng này có tên: cache stampede. Ý tưởng chung mình từng nhắc ở bài thundering herd khi cache hết hạn, còn bài này đi vào cách Go xử lý gọn bằng đúng một package: singleflight.
Vấn đề: 400 người cùng hỏi một câu
Đoạn code cache-aside quen thuộc trông vô hại:
func (s *Store) GetProduct(ctx context.Context, id string) (*Product, error) {
if p, ok := s.cache.Get(id); ok {
return p, nil
}
p, err := s.db.LoadProduct(ctx, id) // expensive query
if err != nil {
return nil, err
}
s.cache.Set(id, p, time.Minute)
return p, nil
}
Mỗi goroutine kiểm tra cache rồi tự đi hỏi DB. Không có gì sai khi traffic thấp. Nhưng khi 400 goroutine cùng miss một key, bạn có 400 query giống hệt nhau, trong khi chỉ cần đúng 1 câu trả lời.
Ảnh: đám đông nhỏ xíu chen cùng lúc vào một cánh cửa duy nhất, giống hàng trăm request cùng đập vào DB khi một key cache vừa hết hạn — ảnh minh hoạ do AI tạo (Grok Imagine)
singleflight làm gì?
Package golang.org/x/sync/singleflight có một ý tưởng đơn giản: với cùng một key, tại một thời điểm chỉ cho một lời gọi hàm thật sự chạy. Các goroutine đến sau không chạy lại, chúng đứng chờ và nhận chung kết quả của lời gọi đầu tiên.
import "golang.org/x/sync/singleflight"
type Store struct {
cache Cache
db DB
group singleflight.Group
}
func (s *Store) GetProduct(ctx context.Context, id string) (*Product, error) {
if p, ok := s.cache.Get(id); ok {
return p, nil
}
v, err, shared := s.group.Do("product:"+id, func() (any, error) {
p, err := s.db.LoadProduct(ctx, id)
if err != nil {
return nil, err
}
s.cache.Set(id, p, time.Minute)
return p, nil
})
if err != nil {
return nil, err
}
_ = shared // true when the result was handed to more than one caller
return v.(*Product), nil
}
400 request vào, 1 query ra DB, 399 goroutine còn lại nhận chung kết quả. Mình thấy đây là kiểu tối ưu rẻ nhất mà hiệu quả nhất: đổi vài dòng code, DB hết bị dội.
Nếu bạn đã quen chạy song song bằng errgroup, cứ hiểu singleflight là "ngược lại": errgroup chia một việc thành nhiều phần chạy cùng lúc, còn singleflight gộp nhiều việc giống nhau thành một.
Ảnh: nhiều tờ giấy giống hệt nhau được gộp lại cho một người đưa tin duy nhất, rồi câu trả lời được chia cho tất cả — đúng cách singleflight cho một lời gọi thật phục vụ mọi goroutine đang chờ — ảnh minh hoạ do AI tạo (Grok Imagine)
Ba cái bẫy mình từng dính
1. Context của người gọi đầu tiên. Trong ví dụ trên, ctx thuộc về request đến đầu tiên. Nếu client đó huỷ request, query bị huỷ, và cả 399 goroutine chờ cùng nhận lỗi context canceled. Cách xử lý: bên trong Do dùng context riêng có timeout (context.WithTimeout(context.WithoutCancel(ctx), 3*time.Second)), còn phía chờ thì tự select theo context của mình.
2. Lỗi cũng được chia sẻ. Nếu lời gọi đầu fail, mọi người chờ cùng nhận lỗi đó. Thường thì chấp nhận được, nhưng đừng cache lỗi lại, và nhớ gọi Forget(key) nếu muốn lần sau thử lại ngay thay vì dính vào lời gọi đang chạy.
3. Panic và goroutine kẹt. Nếu hàm bên trong panic, singleflight sẽ truyền panic đó cho cả nhóm. Hàm bên trong treo thì mọi người chờ cũng treo theo, nên luôn đặt timeout. Dạng treo này rất dễ biến thành goroutine leak nếu bạn không để ý.
Một chi tiết nữa: Do là blocking. Muốn chờ mà vẫn tôn trọng context của chính mình, dùng DoChan:
ch := s.group.DoChan(key, load)
select {
case res := <-ch:
return res.Val.(*Product), res.Err
case <-ctx.Done():
return nil, ctx.Err() // my own deadline, the shared call keeps running
}
Khi nào nên dùng, khi nào không
Nên dùng khi: cùng key bị hỏi dồn dập (trang chi tiết sản phẩm, config, token, kết quả tính toán nặng), hàm bên trong idempotent và không có tác dụng phụ.
Không nên dùng khi: mỗi request cần kết quả riêng theo user (key sai sẽ trả nhầm dữ liệu cho người khác — bug này nghiêm trọng hơn cả stampede), hoặc ghi dữ liệu. Key của singleflight phải chứa mọi thứ làm kết quả khác nhau, kể cả user ID hay ngôn ngữ nếu có.
Cũng cần nhớ singleflight chỉ gộp trong một process. Chạy 20 pod thì tối đa 20 query đồng thời, vẫn tốt hơn hàng nghìn, nhưng nếu cần đúng 1 thì phải thêm lock phân tán hoặc refresh cache nền. Phần chia sẻ state giữa các worker mình có bàn ở bài Arc/Mutex hay channel trong Rust, tư duy khá giống nhau dù khác ngôn ngữ.
Ảnh: một cánh cổng chỉ cho một chiếc đèn lồng đi qua trong khi những chiếc khác xếp hàng chờ, tượng trưng cho việc chỉ một lời gọi chạm tới DB còn các request khác kiên nhẫn đợi kết quả — ảnh minh hoạ do AI tạo (Grok Imagine)
Tự kiểm chứng bằng một test nhỏ
Bạn không cần tin lời mình, viết test là thấy: cho 400 goroutine cùng gọi GetProduct với một key, hàm load giả lập time.Sleep(200 * time.Millisecond) và đếm số lần chạy bằng atomic.AddInt32. Không singleflight thì bộ đếm ra 400, có singleflight thì ra 1 (hoặc vài lần nếu goroutine đến lệch nhịp sau khi lời gọi đầu đã xong). Nhớ chạy với -race cho chắc.
Bạn đang chống stampede bằng cách nào: TTL ngẫu nhiên, refresh nền, hay lock phân tán? Mình khá tò mò xem ngoài singleflight còn cách nào ổn ở production.
📋 Phụ lục thuật ngữ
| Thuật ngữ | Giải thích ngắn |
|---|---|
| Cache stampede | Nhiều request cùng miss một key và cùng đổ về DB |
| singleflight | Package gộp các lời gọi trùng key thành một lời gọi thật |
| Cache-aside | Đọc cache trước, miss thì đọc DB rồi ghi lại vào cache |
| Idempotent | Gọi nhiều lần cho kết quả như gọi một lần |
| DoChan | Bản không chặn của Do, trả kết quả qua channel |
