---
title: "Cache stampede: khi cache hết hạn và hàng loạt request dồn xuống database"
description: "Cache stampede xảy ra khi key hết hạn và nhiều request cùng gọi xuống database. singleflight gộp lời gọi trong một process, TTL jitter rải thời điểm hết hạn."
canonical: "https://200lab.io/blog/cache-stampede-la-gi"
published: "2026-11-18T02:00:04Z"
updated: "2026-11-18T02:00:04Z"
authors: ["Việt Trần"]
tags: ["Backend", "System Design"]
reading_minutes: 14
access: "public"
---

Giả sử key cache của trang chủ shop hết hạn đúng lúc cao điểm, 1000 request cùng thấy cache trống và cùng chạy xuống database để dựng lại trang. Database vốn chỉ cần trả lời một lần thì nay phải trả lời 1000 lần.

**Cache stampede là hiện tượng một key cache hết hạn dưới tải cao khiến nhiều luồng cùng lúc gặp cache miss và đồng loạt tính lại giá trị đó, gây quá tải dây chuyền lên nguồn dữ liệu.**

Trong bài này, mình giải thích cơ chế dẫn đến cache stampede, ba hướng giảm tải phổ biến cùng hai kỹ thuật gần gũi với dev backend là `singleflight` và TTL jitter. Sau đó, mình chạy một demo bằng Go để quan sát số lượng query chạm vào database thay đổi thế nào qua từng kịch bản.

## Cache stampede là gì và vì sao database bị dồn tải

Theo tài liệu [Cache stampede trên Wikipedia](https://en.wikipedia.org/wiki/Cache_stampede), đây là một dạng lỗi dây chuyền (cascading failure) xảy ra dưới tải cao. Khi một key vừa hết hạn, nhiều luồng đi vào cùng lúc đều gặp cache miss và cùng nhảy vào tính lại giá trị đó, còn gọi là dog-piling.

Nguyên nhân bắt nguồn từ chiến lược [cache-aside](/blog/caching-la-gi-cac-chien-luoc-caching-hieu-qua) quen thuộc. Thông thường, service đọc cache trước; nếu trống mới query xuống [database](/blog/database-la-gi) hoặc gọi service khác, rồi ghi kết quả vào cache kèm thời gian sống (TTL).

Ở mức tải bình thường, quy trình này chạy trơn tru vì chỉ vài request thấy cache trống cùng lúc. Nhưng khi truy cập cao, rất nhiều luồng cùng nhận cache miss trước khi luồng đầu tiên kịp ghi dữ liệu mới, khiến tất cả đều tự chạy truy vấn nặng xuống nguồn dữ liệu gốc.

![Key homepage hết hạn: 1000 request cùng cache miss thành 1000 query xuống database](https://assets.200lab.io/sha256/92/92a85fdb34002e61a33c39089ed7c38c34a1d145a4f177aeaa44c173c3471759/generations/67c14ca84e3a645d054a307c95644e28e85111ce5d26578306630251244d0dc1)

Wikipedia mô tả thêm: khi tải đủ cao, việc tính lại đồng loạt có thể làm cạn tài nguyên dùng chung. Khi nguồn dữ liệu nghẽn, các lần tính lại bị timeout nên không luồng nào ghi được vào cache, kéo hit rate tụt về 0 và đẩy hệ thống vào trạng thái sụp đổ vì tắc nghẽn (congestion collapse).

## Ba cách chặn cache stampede: lock, nạp trước, hết hạn sớm

Wikipedia chia cách giảm cache stampede thành ba nhóm chính. Nhóm thứ nhất là dùng cơ chế khóa (locking) khi xảy ra cache miss để giới hạn chỉ một process được chạy hàm tính lại dữ liệu. Các luồng khác đến cùng lúc sẽ chờ kết quả, nhận phản hồi not-found, hoặc tạm đọc bản dữ liệu cũ.

Nhóm thứ hai là tính toán lại từ bên ngoài (external recomputation). Thay vì đợi người dùng gặp cache miss rồi mới query, bạn tách một process riêng chạy ngầm. Process này chủ động tính lại và nạp đè dữ liệu vào cache định kỳ hoặc ngay trước khi TTL chạm mốc hết hạn.

Nhóm thứ ba là làm hết hạn sớm theo xác suất (probabilistic early expiration). Mỗi process khi đọc cache sẽ tự quyết định có tính lại dữ liệu ngay lúc đó hay không, với xác suất tăng dần khi càng gần thời điểm hết hạn. Tiêu biểu cho hướng này là thuật toán XFetch, theo bài báo [Optimal Probabilistic Cache Stampede Prevention tại VLDB 2015](https://www.vldb.org/pvldb/vol8/p886-vattani.pdf) của Vattani và cộng sự.

![Ba nhóm cách chặn cache stampede: locking, external recomputation và early expiration](https://assets.200lab.io/sha256/1b/1bf9050e75b20ae02322480c91bb7771210dc0e7697cada6548f16b00c452995/generations/7b8c9dbeda422a8e40f68e3b49153eeb06bcafbb1bae0a3454dc50c459a8e17e)

## singleflight trong Go gộp request trùng key thế nào

Trong Go, bạn có thể hiện thực nhóm locking ngay trong bộ nhớ của process bằng thư viện [golang.org/x/sync/singleflight trên pkg.go.dev](https://pkg.go.dev/golang.org/x/sync/singleflight) để gộp các lời gọi hàm trùng lặp, đúng như mô tả "duplicate function call suppression" của package. Hàm trung tâm là `Group.Do(key, fn)`: ứng với mỗi `key`, tại một thời điểm chỉ một lần thực thi `fn` được phép chạy. Các caller khác gọi `Do` cùng `key` trong lúc `fn` đầu tiên chưa xong sẽ đứng chờ và nhận về cùng kết quả khi nó hoàn tất.

Hàm `Do` trả về kết quả của `fn`, lỗi nếu có, và biến boolean `shared` cho biết kết quả có được chia sẻ cho nhiều caller hay không. Khi nhiều [goroutines](/blog/goroutines-la-gi) cùng truy cập một tài nguyên đắt đỏ, cơ chế này giúp giảm số lần đánh xuống tầng lưu trữ.

![singleflight gộp 1000 request trùng key thành 1 query, kết quả chia cho mọi caller](https://assets.200lab.io/sha256/c0/c056eea22c0d53d27b05089e39a4943a6301bb9cb660cc099b0c24cb1d53d14a/generations/6f0e76e0b7d8d29f110099a4b56a11289b0a5c89029248c64b41cb967e3a6270)

Ngoài `Do` chặn luồng đồng bộ, bạn có thể gọi `DoChan` để nhận về một [channel](/blog/golang-channel-la-gi) và chủ động chờ qua lệnh `select`. Nếu muốn lần gọi kế tiếp chạy `fn` mới thay vì chờ lần trước đang chạy, bạn gọi `Forget(key)` để Group quên key đó.

Lưu ý rằng `singleflight` chỉ khóa trong phạm vi một process đơn lẻ. Hơn nữa, vì mọi caller chờ cùng nhận một kết quả, nếu hàm `fn` trả về lỗi thì toàn bộ caller đang đợi ở key đó cũng nhận về cùng lỗi y hệt.

## TTL jitter cho nhiều key hết hạn cùng lúc

`singleflight` giải quyết tốt việc nhiều request nhắm vào một key, nhưng thực tế còn kịch bản hàng loạt key khác nhau cùng hết hạn vào đúng một giây. Tình huống này thường xuất hiện khi service vừa khởi động hoặc vừa nạp sẵn cache (cache warming) sau khi deploy.

Nếu bạn gán cho 500 key sản phẩm cùng mức TTL cố định 300 giây, thì đúng 5 phút sau cả 500 key cùng hết hạn. Ngay cả khi mỗi key đã có `singleflight` chặn trùng, mỗi key vẫn cần một lượt nạp, nên giây thứ 300 có thể có tới 500 lượt nạp xuống tầng lưu trữ.

Cách xử lý là áp dụng kỹ thuật TTL jitter: cộng hoặc trừ một khoảng dao động ngẫu nhiên vào TTL gốc của từng key. Thay vì gán cứng 300 giây, mỗi key khi lưu vào cache sẽ nhận mức TTL ngẫu nhiên từ 270 đến 330 giây.

Nhờ khoảng lệch này, thời điểm hết hạn được rải ra theo thời gian thay vì dồn vào một giây. Tóm lại, `singleflight` dùng để gom nhiều request hỏi cùng một key, còn TTL jitter dùng để tách thời điểm hết hạn của nhiều key được tạo cùng lúc.

![TTL jitter rải 500 key hết hạn trên 61 giây, giây bận nhất còn 17 key](https://assets.200lab.io/sha256/2a/2a383ae68af8dcb6a025f61628b896b68a96d9dea19c5c83fdbe5645e40858d8/generations/cddbbcfc1f6d9834175863a6bedacf771f988c15b59a2c06bf8581bff1384f42)

## Chạy thử cache stampede với Go: 1000 request cùng lúc

Để quan sát sự khác biệt, mình viết một chương trình chạy trên máy, không phải môi trường production, dùng Go 1.27.3 trên linux/amd64 và `golang.org/x/sync` v0.25.0. Bản demo dùng `map` kèm `RWMutex` làm cache nội bộ, và cấu trúc `FakeDB` giả lập database với mỗi câu query tốn 50 ms cùng connection pool tối đa 10 kết nối.

Lúc bắt đầu, key `"homepage"` đang trống và chương trình thả 1000 goroutine vào đọc cùng lúc. Mình chạy lặp lại 3 lần đều ra cùng số lượt gọi database, thời gian chỉ dao động nhẹ từ 5033 đến 5040 ms ở nhánh không chặn, còn nhánh có `singleflight` lần nào cũng 51 ms.

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

```go
// cache_stampede.go: 1000 requests hit an expired "homepage" key at the same moment.
// Path A: no protection. Path B: singleflight in one process.
// Path C: singleflight in 4 separate instances. Path D: fixed TTL vs TTL with jitter.
package main

import (
	"fmt"
	"math/rand"
	"sort"
	"sync"
	"sync/atomic"
	"time"

	"golang.org/x/sync/singleflight"
)

// FakeDB counts queries; each query takes 50ms and the pool has 10 connections.
type FakeDB struct {
	calls atomic.Int64
	pool  chan struct{}
}

func NewFakeDB() *FakeDB { return &FakeDB{pool: make(chan struct{}, 10)} }

func (db *FakeDB) LoadHomepage() (string, error) {
	db.pool <- struct{}{} // wait for a free connection
	defer func() { <-db.pool }()
	db.calls.Add(1)
	time.Sleep(50 * time.Millisecond)
	return "homepage-html", nil
}

// Cache is a tiny in-memory cache; the homepage key starts expired (empty).
type Cache struct {
	mu   sync.RWMutex
	data map[string]string
}

func (c *Cache) Get(k string) (string, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	v, ok := c.data[k]
	return v, ok
}

func (c *Cache) Set(k, v string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.data[k] = v
}

// fire starts n requests at the same moment and returns the elapsed time.
func fire(n int, handle func()) time.Duration {
	var wg sync.WaitGroup
	start := make(chan struct{})
	for i := 0; i < n; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			<-start
			handle()
		}()
	}
	t0 := time.Now()
	close(start)
	wg.Wait()
	return time.Since(t0)
}

func pathA(n int) {
	db := NewFakeDB()
	c := &Cache{data: map[string]string{}}
	took := fire(n, func() {
		if _, ok := c.Get("homepage"); ok {
			return
		}
		v, _ := db.LoadHomepage() // every miss goes to the DB
		c.Set("homepage", v)
	})
	fmt.Printf("Path A no protection:        requests=%d db_calls=%d took=%dms\n", n, db.calls.Load(), took.Milliseconds())
}

func pathB(n int) {
	db := NewFakeDB()
	c := &Cache{data: map[string]string{}}
	var g singleflight.Group
	var shared atomic.Int64
	took := fire(n, func() {
		if _, ok := c.Get("homepage"); ok {
			return
		}
		v, _, isShared := g.Do("homepage", func() (any, error) {
			v, err := db.LoadHomepage() // only one caller per key runs this
			if err == nil {
				c.Set("homepage", v)
			}
			return v, err
		})
		_ = v
		if isShared {
			shared.Add(1)
		}
	})
	fmt.Printf("Path B singleflight:         requests=%d db_calls=%d callers_sharing_result=%d took=%dms\n", n, db.calls.Load(), shared.Load(), took.Milliseconds())
}

func pathC(n, instances int) {
	db := NewFakeDB()
	type inst struct {
		c *Cache
		g *singleflight.Group
	}
	pool := make([]inst, instances)
	for i := range pool {
		pool[i] = inst{c: &Cache{data: map[string]string{}}, g: &singleflight.Group{}}
	}
	var next atomic.Int64
	took := fire(n, func() {
		in := pool[int(next.Add(1))%instances] // round-robin like a load balancer
		if _, ok := in.c.Get("homepage"); ok {
			return
		}
		in.g.Do("homepage", func() (any, error) {
			v, err := db.LoadHomepage()
			if err == nil {
				in.c.Set("homepage", v)
			}
			return v, err
		})
	})
	fmt.Printf("Path C singleflight x%d inst: requests=%d db_calls=%d took=%dms\n", instances, n, db.calls.Load(), took.Milliseconds())
}

// pathD: 500 keys are cached in the same second with TTL 300s.
// Count how many keys expire in the busiest second.
func pathD(keys int, ttl, jitter int, seed int64) {
	r := rand.New(rand.NewSource(seed))
	fixed := map[int]int{}
	jit := map[int]int{}
	for i := 0; i < keys; i++ {
		fixed[ttl]++
		j := ttl - jitter + r.Intn(2*jitter+1) // TTL in [ttl-jitter, ttl+jitter]
		jit[j]++
	}
	fmt.Printf("Path D fixed TTL %ds:        keys=%d busiest_second=%d expiring at t=%ds\n", ttl, keys, peak(fixed), ttl)
	sec, n := peakSec(jit)
	fmt.Printf("Path D TTL %ds +/- %ds:      keys=%d busiest_second=%d (t=%ds), spread over %d seconds\n", ttl, jitter, keys, n, sec, len(jit))
}

func peak(m map[int]int) int { _, n := peakSec(m); return n }

func peakSec(m map[int]int) (int, int) {
	secs := make([]int, 0, len(m))
	for s := range m {
		secs = append(secs, s)
	}
	sort.Ints(secs)
	best, bestN := 0, 0
	for _, s := range secs {
		if m[s] > bestN {
			best, bestN = s, m[s]
		}
	}
	return best, bestN
}

func main() {
	const n = 1000
	pathA(n)
	pathB(n)
	pathC(n, 4)
	pathD(500, 300, 30, 42)
}
```

```text
$ go version
go version go1.27.3 linux/amd64
$ go run .
Path A no protection:        requests=1000 db_calls=1000 took=5033ms
Path B singleflight:         requests=1000 db_calls=1 callers_sharing_result=1000 took=51ms
Path C singleflight x4 inst: requests=1000 db_calls=4 took=51ms
Path D fixed TTL 300s:        keys=500 busiest_second=500 expiring at t=300s
Path D TTL 300s +/- 30s:      keys=500 busiest_second=17 (t=299s), spread over 61 seconds
```

Ở Path A, khi không chặn trùng, 1000 request cùng thấy cache trống nên tạo đủ 1000 lượt gọi xuống `FakeDB`. Do pool chỉ có 10 connection và mỗi lượt mất 50 ms, hệ thống phải chia thành 100 đợt nối đuôi nhau, kéo tổng thời gian lên 5033 ms.

Sang Path B, đặt `singleflight` trong một process giúp 1000 request đi vào chỉ tạo đúng 1 lượt gọi `FakeDB`, tốn 51 ms. Thông số `callers_sharing_result` báo 1000 vì biến `shared` trả về `true` cho tất cả luồng tham gia, tính cả luồng đầu tiên chạy hàm nạp lẫn 999 luồng chờ kết quả.

Ở Path C, mình giả lập pattern chạy 4 instance riêng biệt với cache và `Group` riêng, 1000 request được chia vòng tròn giống cách một [load balancer](/blog/load-balancer-la-gi-chia-khoa-cho-hieu-suat-va-do-tin-cay) chạy round robin. Kết quả ghi nhận `db_calls=4` và mất 51 ms, cho thấy `singleflight` chỉ gom trong một process; nếu mở rộng ra N instance thì database vẫn có thể nhận tới N query cho cùng một key.

![4 instance, mỗi instance một singleflight riêng, nên database vẫn nhận 4 query](https://assets.200lab.io/sha256/da/daba704d56265b23ff1a32560e54a3d27b177bd02fb1b50c5fc01903bcdf1072/generations/bf720c686dfaa8b92fbe85d99e136d91b3bcc343f138f76be8257357ecec9d4d)

Nhánh Path D mô phỏng 500 key nạp cùng lúc dùng bộ sinh số ngẫu nhiên seed 42 thay vì chờ thật 300 giây. Với TTL cố định 300 giây, cả 500 key hết hạn tại giây 300; nhưng khi cộng trừ jitter 30 giây, lượng key hết hạn ở giây bận nhất (giây 299) giảm còn 17 key, số còn lại rải trên 61 giây.

Lưu ý rằng pool 10 connection của `FakeDB` chỉ là mức giả lập để dễ thấy hiện tượng xếp hàng, bạn đừng lấy mốc 5 giây này suy ra cho production. Demo này cũng không đo CPU, không nối database thật và chưa cài thử thuật toán XFetch.

Ngoài ra, `singleflight` chỉ gom những lời gọi trùng key trong cùng process khi lời gọi đầu tiên còn đang chạy. Nếu hàm nạp bị treo lâu, mọi caller đi sau sẽ bị giữ chân chờ theo, còn nếu hàm lỗi thì mọi caller đang chờ cùng nhận lỗi đó.

## Khi nào singleflight chưa đủ và sai lầm hay gặp

Sai lầm đầu tiên khi áp dụng các [concurrency pattern trong Go](/blog/concurrency-pattern-trong-go) là mặc định `singleflight` gộp được request giữa nhiều server, trong khi nhánh C đã chỉ ra 4 instance vẫn tạo 4 lượt truy vấn. Nếu query cực nặng và muốn gom về 1 lượt trên toàn cụm, bạn cần khóa phân tán trên [Redis](/blog/redis-la-gi) hoặc tách process riêng chuyên nạp dữ liệu.

Sai lầm thứ hai là thiết kế key truyền vào `singleflight` quá rộng hoặc quá hẹp so với key cache, khiến các luồng bị chặn nhầm hoặc lọt lưới. Đồng thời, quên gắn timeout cho query trong hàm nạp sẽ khiến một kết nối kẹt kéo theo hàng trăm request đứng đợi.

Ngược lại, bọc `singleflight` cho những key ít người đọc chỉ làm code phức tạp mà không đem lại lợi ích rõ rệt. Trong khi đó, thói quen gán cùng một TTL tròn trĩnh cho hàng loạt key lúc khởi động lại gây dồn tải theo chu kỳ như ở nhánh D.

Với hệ thống tải lớn cho phép dữ liệu trễ một chút, bạn có thể trả về ngay bản cũ trong lúc nạp ngầm bản mới, hoặc chuyển sang external recomputation để giảm độ trễ chờ. Ngoài ra, để tránh bão retry khi tầng lưu trữ đang chậm, bạn nên thêm jitter vào thời gian chờ thử lại, kết hợp [rate limiting](/blog/rate-limiting-la-gi) và [circuit breaker](/blog/circuit-breaker-la-gi) nhằm bảo vệ nguồn dữ liệu.

Mình chọn đặt `singleflight` kèm timeout trước những key nóng tốn chi phí tính toán, vì trong demo nó giúp gom 1000 lượt gọi xuống còn 1 lượt trong một process. Song song đó, mình cộng thêm TTL jitter cho các nhóm key nạp hàng loạt để rải đỉnh tải, giống cách giảm từ 500 key cùng giây xuống tối đa 17 key ở phần mô phỏng. Riêng khi service chạy trên nhiều instance mà câu query quá đắt đỏ, mình sẽ bổ sung khóa phân tán trên Redis hoặc tách process làm mới cache thay vì chỉ dựa vào `singleflight` nội bộ.

## Đọc thêm

- [Caching là gì và các chiến lược caching hiệu quả](/blog/caching-la-gi-cac-chien-luoc-caching-hieu-qua): ôn cách cache-aside, write-through và write-back giữ dữ liệu giữa cache và database.
- [Redis là gì](/blog/redis-la-gi): ôn các tính năng chính của Redis, một lựa chọn quen thuộc cho cache dùng chung giữa nhiều instance.
- [Goroutines là gì](/blog/goroutines-la-gi): hiểu goroutine, thứ demo dùng để thả 1000 request cùng lúc.
- [Concurrency pattern trong Go](/blog/concurrency-pattern-trong-go): các pattern xử lý đồng thời trong Go như or-channel và pipeline.

## Đọc thêm

- [Connection pool là gì, vì sao service Go treo dù database còn rảnh](https://200lab.io/blog/connection-pool-la-gi.md): Service Go timeout hàng loạt trong khi database vẫn rảnh? Bài này giúp bạn hiểu connection pool trong Go hoạt động ra sao và cách chỉnh pool cho đúng tải.
- [Outbox pattern: ghi database và gửi message mà không mất đơn](https://200lab.io/blog/outbox-pattern-la-gi.md): Outbox pattern là gì: ghi đơn và event trong cùng một transaction, rồi relay gửi sau; demo PostgreSQL cho thấy dual-write làm mất message khi service restart.
- [Retry với backoff và jitter: gọi lại API lỗi mà không làm sập server](https://200lab.io/blog/retry-la-gi.md): 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.
- [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.
- [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
