Herausforderung: Planung mit Promises

„Scheduling“ bedeutet zu entscheiden, wie eine Liste asynchroner Aufgaben (Tasks) ausgeführt werden soll: alle auf einmal, nacheinander oder in kleinen Gruppen. Wir kombinieren hierfür Promise.all, for await und Closures.

Parallel: Alle auf einmal

Wenn die Aufgaben unabhängig und schnell sind, starte sie alle gleichzeitig und warte mit Promise.all auf sie:

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]

Gesamtzeit ≈ Zeit des langsamsten Tasks.

Seriell: Nacheinander

Wenn jeder Task vom vorherigen abhängt oder du ein Rate-Limit einhalten willst:

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

Gesamtzeit ≈ Summe der Einzelzeiten.

Mit Nebenläufigkeitsbegrenzung (Concurrency Limit)

Manchmal möchtest du weder tausend Anfragen gleichzeitig senden noch sie nacheinander abarbeiten: Du möchtest maximal N aktive Anfragen gleichzeitig laufen haben.

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;
}

Idee: Du startest n „Worker“, die sich jeweils den nächsten Index holen, solange noch Aufgaben vorhanden sind.

Probier es aus

Wiederholungsübung