Apakah strategi dan corak caching yang wujud dengan Redis?

Question

Accepted Answer

Melebihi cache-aside asas, terdapat beberapa **strategi caching** — cache-aside, write-through, write-behind, read-through — setiap satu dengan pertukaran konsistensi dan prestasi yang berbeza. Memahaminya (dan dasar eviction) membantu anda mereka bentuk caching yang berkesan.

## Cache-aside (lazy loading — paling biasa)

```text
App checks cache → miss → load from DB → populate cache → return.
  ✓ Only requested data is cached (efficient); resilient (works if cache is down)
  ✗ First request is a miss (slower); cache can be stale until TTL/invalidation
→ The default, most common strategy.
```

## Write-through dan write-behind

```text
WRITE-THROUGH → write to cache AND DB together (synchronously) on every write
  ✓ Cache always fresh/consistent  ✗ Writes are slower (two writes); caches unread data

WRITE-BEHIND (write-back) → write to cache immediately, write to DB ASYNC later
  ✓ Fast writes  ✗ Risk of data loss if cache fails before the DB write; more complex
```

## Read-through

```text
READ-THROUGH → the cache layer itself loads from the DB on a miss (abstracted)
  → app just reads from the cache; the cache handles DB loading transparently
  (similar to cache-aside but the loading logic lives in the cache layer/library)
```

## Dasar eviction (apabila memori penuh)

```text
When Redis hits its memory limit (maxmemory), it EVICTS keys per a policy:
  LRU (Least Recently Used)  → evict least-recently-accessed (good general default)
  LFU (Least Frequently Used)→ evict least-frequently-accessed
  TTL-based (volatile-ttl)   → evict keys closest to expiry
  random / noeviction        → random, or reject writes when full
→ allkeys-lru is a common choice for a pure cache. Set maxmemory + a policy.
```

## Mengelakkan masalah cache

```text
✓ Cache STAMPEDE (many misses at once hammering the DB) → locking, staggered TTLs
✓ Stale data → appropriate TTLs + invalidation on writes
✓ Cache PENETRATION (querying non-existent keys) → cache negative results briefly
```

## Mengapa ia penting

Memahami strategi caching adalah bernilai untuk **mereka bentuk sistem caching yang berkesan**, dibina di atas cache-aside asas, jadi ia adalah pengetahuan yang berguna untuk kerja berfokuskan prestasi.

Walaupun cache-aside (lazy loading — menyemak cache, memuat dari DB apabila miss, mengisi cache) ialah lalai biasa, memahami **julat strategi** membolehkan anda memilih yang betul untuk situasi: **write-through** (menulis ke cache dan DB bersama untuk cache yang sentiasa segar dengan kos tulisan lebih perlahan), **write-behind** (menulis ke cache serta-merta dan DB secara asinkron untuk tulisan pantas tetapi dengan risiko kehilangan data), dan **read-through** (lapisan cache memuat dari DB secara telus) — setiap satu dengan pertukaran konsistensi/prestasi tersendiri yang penting untuk keperluan konsistensi dan corak tulisan yang berbeza.

Memahami **dasar eviction** (LRU, LFU, berasaskan TTL, dll. — bagaimana Redis memutuskan key mana hendak dibuang apabila memori penuh) adalah penting untuk mengkonfigurasi Redis sebagai cache dengan betul (menetapkan `maxmemory` dan dasar yang sesuai seperti `allkeys-lru` untuk cache tulen), supaya ia berkelakuan baik di bawah tekanan memori.

Mengetahui cara **mengelakkan masalah cache biasa** — cache **stampede** (banyak miss serentak menghantam pangkalan data, dikurangkan dengan locking atau TTL berperingkat), **data lapuk** (diuruskan dengan TTL dan invalidation), dan cache **penetration** (pertanyaan berulang untuk key yang tidak wujud, dikurangkan dengan caching hasil negatif) — mencerminkan reka bentuk caching matang yang mengelakkan isu pengeluaran sebenar.

Memandangkan caching yang berkesan memberi impak besar kepada prestasi dan strategi/konfigurasi yang betul bergantung pada kes penggunaan, dan kerana memahami strategi, dasar eviction, dan perangkap biasa membolehkan mereka bentuk caching yang kukuh, memahami strategi dan corak caching adalah pengetahuan bernilai yang relevan dari segi praktikal untuk kejuruteraan prestasi dengan Redis, menaikkan caching daripada corak asas kepada sistem yang direka bentuk dengan baik yang mengendalikan konsistensi, memori, dan mod kegagalan dengan betul.