Accueil › Node.js › Le cache, et ce qu'il coûte
Le cache, et ce qu'il coûte
Performance et montée en chargeavance
Un cache ne supprime pas un problème. Il l'échange contre trois autres : l'invalidation, la cohérence entre instances, et la ruée quand l'entrée expire.
Les trois décisions
const cache = new Map();
function cle(params) {
// canonique : seuls les paramètres qui changent la réponse, triés
return ["produits", params.categorie, params.tri ?? "defaut", params.page ?? 1].join("|");
}
async function lireProduits(params) {
const k = cle(params);
const entree = cache.get(k);
if (entree && entree.expireA > Date.now()) return entree.valeur;
const valeur = await requeteBase(params);
cache.set(k, { valeur, expireA: Date.now() + 60_000 }); // durée explicite
return valeur;
}
Trois choses sont décidées ici, et chacune se discute : la clé est canonique, la durée de vie est explicite, et le cache est local au processus — donc huit instances servent huit versions différentes.
La ruée
À l'instant où expireA est dépassé, toutes les requêtes en cours trouvent le
cache vide et partent toutes vers la base. Si le recalcul prend 300 ms sous
200 requêtes par seconde, cela fait soixante requêtes identiques.
const enVol = new Map();
function lireAvecVerrou(k, calculer) {
const entree = cache.get(k);
if (entree && entree.expireA > Date.now()) return entree.valeur;
if (enVol.has(k)) return enVol.get(k); // un seul recalcul
const p = calculer().then((valeur) => {
cache.set(k, { valeur, expireA: Date.now() + 60_000 });
enVol.delete(k);
return valeur;
}, (e) => { enVol.delete(k); throw e; });
enVol.set(k, p);
return p;
}
Stocker la promesse et non la valeur suffit : les demandes concurrentes reçoivent la même, et un seul recalcul part.
Ce qu'un cache coûte
De la mémoire, de l'incohérence, et un chemin de code de plus à déboguer. Il ne se justifie que si le taux de coups au but est élevé et la donnée tolérante au retard.
Les termes à connaître
- Clé canonique
Une clé construite de façon déterministe à partir des paramètres qui changent la réponse, et d'eux seuls. Deux requêtes équivalentes doivent produire la même clé.
- Durée de vie
Le temps pendant lequel une entrée reste servie sans être recalculée. Elle est toujours explicite : un cache sans durée de vie est une fuite de mémoire qui sert des données périmées.
- Invalidation
Retirer une entrée devenue fausse avant son expiration. C'est le problème difficile du cache, parce qu'il faut savoir quelles clés une écriture rend fausses.
- Ruée à l'expiration
À l'instant où une entrée très demandée expire, toutes les requêtes en cours recalculent la même valeur en même temps.
- Verrou de rafraîchissement
Un marqueur qui autorise un seul recalcul à la fois pour une clé donnée. Les autres demandes attendent ou servent la valeur périmée.
- Rafraîchissement anticipé
Recalculer une entrée un peu avant son expiration, pendant qu'elle est encore servie. Il n'y a alors jamais de trou.
- Taux de coups au but
La part des lectures servies depuis le cache. En dessous d'un certain seuil, le cache coûte plus qu'il ne rapporte.
Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.