Wat is een cache stampede en hoe voorkom je dit?

Question

Accepted Answer

Een **cache stampede** (of dogpile) gebeurt wanneer een populaire gecachte sleutel verloopt en **veel gelijktijdige verzoeken het tegelijk missen**, allemaal teruggaand naar de bron om dezelfde waarde gelijktijdig opnieuw te berekenen. De bron (database of service) wordt overstelpt door een burst die het niet aankan, soms resulterend in systeemuitval.

## De oorzaak

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

De trigger is **gelijktijdig verlopen** van een populaire sleutel. De oplossing is ervoor zorgen dat alleen één (of enkele) herberekening plaatsvindt, of dat verzoeken niet allemaal tegelijk verlopen.

## Oplossingen

- **Vergrendeling / single-flight** — het eerste cache miss neemt een lock en herberekent; iedereen anders wacht op dat ene resultaat in plaats van allemaal de bron te raken.
- **Stale-while-revalidate** — serveer de licht verouderde waarde onmiddellijk terwijl één achtergrondtaak deze vernieuwt. Geen enkel verzoek blokkeert op de bron.
- **Vroege / probabilistische herberekening** — vernieuw een sleutel *voordat* deze verloopt, met een waarschijnlijkheid die toeneemt naarmate het verloopen nadert, zodat één toevallig verzoek deze voor de stampede herbouwt.
- **Verspreid TTLs** — voeg willekeurigheid toe aan TTLs zodat sleutels niet allemaal tegelijk verlopen.
- **Verzoeken samenvoegen** — vouw identieke gelijktijdige verzoeken samen tot één bronoproep.

## Single-flight pseudo-code

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

De lock zorgt ervoor dat exact één bronoproep plaatsvindt; elk ander gelijktijdig verzoek wacht en leest vervolgens de vers gecachte waarde.

## Waarom het belangrijk is

Een stampede verandert een routinematig cache-verlopen in een storing: de cache die je database beschermde, werkt plots niet meer, en al het verkeer belandt tegelijk op de bron. Het begrijpen van de oorzaak (gelijktijdig verlopen van populaire sleutels) en de oplossingen (single-flight, stale-while-revalidate, jitter) is essentieel voor het handhaven van betrouwbare caches onder echte belasting.