Kiến Trúc Bộ Nhớ Đệm Đa Tầng (Multi-Tier Caching) & Khống Chế Thảm Họa Cache Stampede

Các Biến Cố Sụp Đổ Hệ Thống Bắt Nguồn Từ Cache

Khi kiến trúc hệ thống phụ thuộc vào tầng Cache để bảo vệ cơ sở dữ liệu phía sau, bất kỳ sự cố rò rỉ hoặc mất cân bằng nào cũng có thể dẫn tới sự cố domino đánh sập toàn bộ dịch vụ:

1. Cache Penetration (Xuyên thủng cache): Kẻ tấn công hoặc lỗi client gửi hàng triệu request tìm kiếm các ID không hề tồn tại. Cache luôn bị Miss và mọi truy vấn lao thẳng xuống cơ sở dữ liệu chính.
2. Cache Avalanche (Tuyết lở cache): Một số lượng lớn các cache key quan trọng được gán cùng một thời gian sống (TTL = 1 giờ). Đúng 60 phút sau, toàn bộ các key này đồng loạt bốc hơi, dồn toàn bộ tải đọc lên database cùng một giây.
3. Cache Breakdown / Cache Stampede (Vỡ đê cache / Dog-piling): Một "Hot Key" (ví dụ: thông tin trang chủ hoặc sản phẩm siêu khuyến mãi) với hàng vạn request/giây bất ngờ hết hạn. Hàng vạn kết nối đồng thời phát hiện Cache Miss và cùng lúc gửi truy vấn phức tạp tới database để tính toán lại giá trị.

Kiến Trúc Đa Tầng: L1 (In-Memory) + L2 (Redis Cluster)

code(21 dòng)
Sao chép
Client Request
      |
      v
+------------------+     HIT (<50ns)
| L1 Cache (Local) | -------------> Trả về ngay lập tức
+------------------+
      | MISS
      v
+------------------+     HIT (<2ms)
| L2 Cache (Redis) | -------------> Nạp ngược lại L1 & Trả về
+------------------+
      | MISS
      v
+------------------+
|   Singleflight   | -------------> Chỉ 1 request được gọi DB
+------------------+
      |
      v
+------------------+
|  Database (Postgres)
+------------------+

Thiết Kế L1 Cache Phi Cấp Phát (Zero-GC)

Nếu lưu trữ hàng triệu object trong map Go thông thường (map[string]*User), bộ thu gom rác Go sẽ phải duyệt qua từng con trỏ trong map, gây STW pause kéo dài. Giải pháp là sử dụng các thư viện như FreeCache hoặc BigCache, nơi dữ liệu được lưu dưới dạng một mảng []byte nguyên khối không chứa con trỏ bên trong.

Triệt Tiêu Cache Stampede Bằng Go Singleflight

Go cung cấp một gói thư viện tuyệt vời trong golang.org/x/sync/singleflight. Cơ chế của nó cho phép gộp hàng nghìn lời gọi hàm trùng lặp về cùng một key diễn ra đồng thời thành một lời gọi duy nhất:

go(49 dòng)
Sao chép
package cache

import (
    "context"
    "encoding/json"
    "time"

    "github.com/redis/go-redis/v9"
    "golang.org/x/sync/singleflight"
)

type MultiTierCache struct {
    rdb   *redis.Client
    group singleflight.Group
}

func (c *MultiTierCache) GetArticle(ctx context.Context, slug string) (*Article, error) {
    cacheKey := "article:" + slug

    // 1. Kiểm tra L2 Redis Cache
    val, err := c.rdb.Get(ctx, cacheKey).Bytes()
    if err == nil {
        var a Article
        if json.Unmarshal(val, &a) == nil {
            return &a, nil
        }
    }

    // 2. Cache Miss: Dùng Singleflight để chỉ 1 goroutine gọi xuống Database
    result, err, _ := c.group.Do(cacheKey, func() (any, error) {
        // Chỉ goroutine đầu tiên chạy vào đây
        article, dbErr := fetchArticleFromDB(ctx, slug)
        if dbErr != nil {
            return nil, dbErr
        }

        // Ghi ngược lại Redis kèm TTL có Jitter
        data, _ := json.Marshal(article)
        ttl := 30*time.Minute + time.Duration(time.Now().UnixNano()%300)*time.Second
        c.rdb.Set(context.Background(), cacheKey, data, ttl)

        return article, nil
    })

    if err != nil {
        return nil, err
    }
    return result.(*Article), nil
}

Chiến Lược Jittered TTL & Tính Toán Sớm (Probabilistic Early Expiration)

1. Phân Tán TTL Bằng Jitter

Không bao giờ gán số cố định cho TTL:

go(6 dòng)
Sao chép
// ANTI-PATTERN: Tất cả key hết hạn cùng lúc
ttl := 1 * time.Hour

// TỐI ƯU: Cộng thêm ngẫu nhiên +/- 10%
jitter := time.Duration(rand.Intn(600)) * time.Second
ttl := 1*time.Hour + jitter

2. Thuật Toán XFetch (Tính Toán Sớm)

Thuật toán dự đoán trước thời điểm key sắp hết hạn để tính toán lại trong nền trước khi request thật sự nhận Cache Miss:

$$\Delta - \beta \times \ln(\text{random}()) > \text{TTL}$$

Trong đó $\Delta$ là thời gian tính toán của truy vấn, $\beta > 0$ là hệ số tích cực. Khi thỏa mãn điều kiện, một worker chạy nền sẽ nạp lại dữ liệu sớm, bảo đảm người dùng luôn nhận được cache tươi mới mà không bao giờ phải chịu cảm giác khựng lại do chờ nạp cache.