Ce este o avalanșă de cache și cum o previi?

Question

Accepted Answer

O **avalanșă de cache** (sau dogpile) se întâmplă când o cheie cache fierbinte expiră și **mulți cereri concurente o pierd deodată**, cădând în același timp la origine pentru a recalcula aceeași valoare simultan. Originea (BD sau serviciu) este bombardată cu o explozie pe care nu o poate gestiona, uneori ducând sistemul în jos.

## Cauza

```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
```

Declanșatorul este **expirarea simultană** a unei chei populare. Soluția este să asiguri că doar una (sau câteva) recalculări se întâmplă, sau că cererile nu expiră toate în același moment.

## Soluții

- **Locking / single-flight** — prima pierdere ia un lock și recalculează; toți ceilalți așteaptă acel unui singur rezultat în loc să lovească toți originea.
- **Stale-while-revalidate** — servește valoarea ușor expirată imediat în timp ce o sarcină de fundal o reîmprospătează. Nicio cerere nu se blochează pe origine.
- **Early / probabilistic recomputation** — reîmprospătează o cheie *înainte* ca ea să expire, cu o probabilitate care crește pe măsură ce expirarea se apropie, astfel încât o cerere norocoasă să o reconstruiască înainte de avalanșă.
- **Jittered TTLs** — adaugă aleatorietate la TTLs pentru ca cheile să nu expirez toate în același instant.
- **Request coalescing** — combină cererile concurente identice într-un singur apel la origine.

## Pseudo-cod single-flight

```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
```

Lock-ul asigură exact un apel la origine; toate celelalte cereri concurente așteaptă și apoi citesc valoarea proaspăt cache-uită.

## De ce conține

O avalanșă transformă o expirare obișnuită a cache-ului într-o cădere: cache-ul care îți proteja BD-ul brusc se oprește, și traficul complet ajunge la origine deodată. Cunoașterea cauzei (expirarea simultană a cheilor fierbinți) și a soluțiilor (single-flight, stale-while-revalidate, jitter) este esențială pentru a menține cache-urile fiabile sub sarcină reală.