Défi : planification avec des Promesses

L'« ordonnancement » (scheduling) consiste à décider de la manière d'exécuter une liste de tâches asynchrones : toutes en même temps, une par une, ou par petits groupes. Nous allons combiner Promise.all, for await et des fermetures (closures).

En parallèle : tout en même temps

Lorsque les tâches sont indépendantes et rapides, lancez-les toutes et attendez-les avec Promise.all :

async function inParallelo(tasks) {
  return Promise.all(tasks.map((t) => t()));
}

const risultati = await inParallelo([
  () => Promise.resolve(1),
  () => Promise.resolve(2),
  () => Promise.resolve(3),
]);
// [1, 2, 3]

Temps total ≈ temps de la tâche la plus lente.

En série : une par une

Lorsque chaque tâche dépend de la précédente, ou si vous souhaitez limiter le débit (rate-limit) :

async function inSerie(tasks) {
  const risultati = [];
  for (const t of tasks) {
    risultati.push(await t());
  }
  return risultati;
}

Temps total ≈ somme des temps individuels.

Avec limite de concurrence

Parfois, vous ne voulez pas lancer mille requêtes simultanées, mais pas non plus les attendre en série : vous souhaitez avoir un maximum de N requêtes actives.

async function conLimite(tasks, n) {
  const risultati = new Array(tasks.length);
  let i = 0;
  async function worker() {
    while (i < tasks.length) {
      const mio = i++;
      risultati[mio] = await tasks[mio]();
    }
  }
  await Promise.all(Array.from({ length: n }, worker));
  return risultati;
}

Idée : vous lancez n « workers » qui récupèrent l'indice suivant tant qu'il reste du travail à faire.

À vous de jouer

Exercice de révision