Mi az cache stampede és hogyan akadályozod meg?

Question

Accepted Answer

A **cache stampede** (vagy dogpile) akkor fordul elő, amikor egy népszerű, gyorsítótárban lévő kulcs lejár, és **sok egyidejű kérés egyszerre hibaüzenetet kap**, mindegyik visszaesik az eredetre, hogy egyidejűleg újraszámítsa az ugyanazt az értéket. Az eredetet (adatbázis vagy szolgáltatás) olyan hirtelen terhelésel bombázzák meg, amelyet nem tud kezelni, néha a rendszert leállítva.

## Az ok

```text
t=0   hot key expires
t=0+  1000 requests arrive → all miss → all query the DB for the SAME value
      → DB overwhelmed; latency spikes; failures cascade
```

Az indítók az **egyidejű lejárati** egy népszerű kulcsé. A javítás annak biztosítása, hogy csak egy (vagy kevés) újraszámítás történjen, vagy hogy a kérések ne járjanak le egyszerre.

## Javítások

- **Zárolás / single-flight** — az első hiba zárral rendelkezik és újraszámít; az összes többi arra vár, hogy az egyik eredményre, ahelyett, hogy az összes az eredetre ütne.
- **Stale-while-revalidate** — azonnal szolgálja ki az enyhén elavult értéket, miközben egy háttérfeladat frissíti. Nem valami kérés nem blokkolt az eredeten.
- **Korai / valószínűségi újraszámítás** — frissítsen egy kulcsot *mielőtt* lejárna, olyan valószínűséggel, amely növekszik a lejárat közeledtével, így egy szerencsés kérés újraépíti a stampede előtt.
- **Jittered TTLs** — adjunk véletlenszámot a TTL-ekhez, hogy az összes kulcs ne járjon le egyidejűleg.
- **Kérések összevonása** — identikus egyidejű kéréseket egyetlen eredeti hívásba omlesztsen.

## Single-flight pszeudo-kód

```text
function get(key):
  val = cache.get(key)
  if val is present: return val            // fast path: a hit

if lock.acquire(key, ttl=5s):            // only ONE request wins the lock
    try:
      val = recompute()                    // hit the origin exactly once
      cache.set(key, val, ttl)
    finally:
      lock.release(key)
    return val
  else:
    wait_briefly(); return get(key)        // others wait, then read the filled cache
```

A zár pontosan egy eredeti hívást biztosít; minden más egyidejű kérés vár, majd beolvassa az újonnan gyorsítótárazott értéket.

## Miért fontos ez

A stampede egy rutinszerű gyorsítótár-lejáratot áramszünetté alakít: az a gyorsítótár, amely az adatbázisod védelme alatt állt, hirtelen leállítva, és a teljes forgalom egyszerre az eredetre esik. A kiváltó ok (forró kulcsok egyidejű lejárata) és a javítások (single-flight, stale-while-revalidate, jitter) ismerete elengedhetetlen ahhoz, hogy a gyorsítótárat valós terhelés alatt megbízhatóan tartsd.