Qu'est-ce qu'un cache stampede et comment l'éviter ?

Question

Accepted Answer

Un **cache stampede** (ou dogpile) se produit quand une clé en cache très sollicitée expire et que **plusieurs requêtes concurrentes la manquent simultanément**, remontant toutes à l'origine pour recalculer la même valeur au même moment. L'origine (base de données ou service) est bombardée par un pic qu'elle ne peut pas gérer, ce qui peut parfois mettre le système hors ligne.

## La cause

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

Le déclencheur est **l'expiration simultanée** d'une clé populaire. La solution consiste à s'assurer qu'un seul (ou peu de) recalcul se produit, ou que les requêtes n'expirent pas toutes ensemble.

## Solutions

- **Verrous / single-flight** — la première manquée acquiert un verrou et recalcule ; tous les autres attendent ce seul résultat au lieu de tous frapper l'origine.
- **Stale-while-revalidate** — servir immédiatement la valeur légèrement périmée tandis qu'une tâche de fond la rafraîchit. Aucune requête ne bloque sur l'origine.
- **Recalcul précoce / probabiliste** — rafraîchir une clé *avant* son expiration, avec une probabilité qui augmente à mesure que l'expiration approche, de sorte qu'une requête chanceuse la reconstruise avant le stampede.
- **TTLs avec gigue** — ajouter de l'aléatoire aux TTLs pour que les clés n'expirent pas toutes au même instant.
- **Coalescence de requêtes** — fusionner les requêtes concurrentes identiques en un seul appel à l'origine.

## Pseudo-code 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
```

Le verrou garantit exactement un appel à l'origine ; chaque autre requête concurrente attend puis lit la valeur fraîchement mise en cache.

## Pourquoi c'est important

Un stampede transforme une expiration de cache de routine en une panne : le cache qui protégeait votre DB disparaît soudainement, et tout le trafic arrive sur l'origine à la fois. Connaître la cause (expiration simultanée de clés chaudes) et les solutions (single-flight, stale-while-revalidate, gigue) est essentiel pour maintenir les caches fiables sous charge réelle.