Formations — 1 037 leçons en français

Accueil › Node.js › Séquentiel, parallèle, limité

Séquentiel, parallèle, limité

L'asynchrone côté serveurintermediaire

Trois appels indépendants, trois façons de les exécuter — et trois latences très différentes.

Séquentiel : la somme

const client = await getClient(id);        // 100 ms
const commandes = await getCommandes(id);  // 200 ms
const factures = await getFactures(id);    // 300 ms
// total ≈ 600 ms

Chaque await suspend la fonction. Le deuxième appel n'est pas encore parti quand le premier attend. Correct seulement si l'appel suivant a besoin du résultat du précédent.

Parallèle : le maximum

const [client, commandes, factures] = await Promise.all([
  getClient(id),
  getCommandes(id),
  getFactures(id),
]);
// total ≈ 300 ms

Les trois appels sont lancés à la création des promesses, avant le premier await. Même nombre d'appels réseau, latence divisée par deux.

Limité : ni l'un ni l'autre

// ⛔ dix mille connexions ouvertes d'un coup
await Promise.all(dixMilleIds.map((id) => getClient(id)));

Le pool de connexions détient une dizaine de jetons. Les autres requêtes attendent, expirent, et le message d'erreur parle d'acquisition de connexion — pas de la vraie cause. Au-delà de quelques dizaines d'éléments, on borne la concurrence.

Choisir le combinateur

Besoin Combinateur
Tout doit réussir Promise.all
L'échec partiel est acceptable Promise.allSettled
Le premier succès suffit Promise.any
Le premier terminé, succès ou échec Promise.race

Les termes à connaître

Séquentiel

Un await après l'autre. La latence totale est la somme des latences. Correct quand chaque appel a besoin du résultat du précédent, gaspillage sinon.

Parallèle

Les appels sont lancés avant d'être attendus, par exemple avec Promise.all. La latence totale est le maximum des latences, pas leur somme.

Concurrence limitée

Un nombre maximal de travaux en vol à un instant donné. On lance le suivant quand une place se libère, jamais mille d'un coup.

Promise.all

Rend un tableau de résultats dans l'ordre des entrées, et rejette au premier rejet. Les autres travaux continuent, sans que personne n'attende leur résultat.

Promise.allSettled

Attend tous les travaux et rend un tableau de { status, value } ou { status, reason }. Ne rejette jamais. C'est le choix quand l'échec partiel est acceptable.

Promise.any

Rend le premier succès et n'échoue que si tous rejettent, avec une AggregateError. Utile pour interroger deux réplicas et garder le plus rapide.

Épuisement du pool

Un parallélisme non borné réclame plus de connexions que le pool n'en possède. Les requêtes attendent un jeton, puis expirent — la base n'est pas en panne, le pool l'est.

Lire l'explication détaillée et faire le quiz →

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.