mitmario.dev

Parallel oder nacheinander

Node.js Sandbox 3 Min Lesezeit 4 BeispieleLektion 4 von 7

Zwanzig Vorgänge zu je hundert Millisekunden brauchen mit await in einer Schleife zwei Sekunden, auch wenn keiner auf den anderen angewiesen ist. Auf diese Weise wird in echtem Node-Code oft gewartet, obwohl niemand warten müsste.

Die Schleife, die keiner für langsam hält

Die Schleife mit await darin
const holen = (nummer) =>
  new Promise((fertig) => setTimeout(() => fertig(`Datei ${nummer}`), 100));

const start = performance.now();
const ergebnisse = [];

for (const nummer of [1, 2, 3, 4, 5]) {
  ergebnisse.push(await holen(nummer));
}

console.log(`${ergebnisse.length} geholt`);
console.log(`Gedauert: etwa ${Math.round((performance.now() - start) / 100) * 100} ms`);

Gemessen sind es fünfmal hundert Millisekunden, also fünfhundert. Hat man das einmal gesehen, leuchtet es sofort ein. Beim Schreiben sieht man es nur nicht, weil await in einer Schleife völlig normal aussieht.

Bei fünf Dateien fällt das niemandem auf. Bei zwanzig wundert man sich irgendwann, warum die Seite so lahm ist.

Erst alle starten, dann einmal warten

Dieselbe Arbeit mit Promise.all
const holen = (nummer) =>
  new Promise((fertig) => setTimeout(() => fertig(`Datei ${nummer}`), 100));

const start = performance.now();

const ergebnisse = await Promise.all([1, 2, 3, 4, 5].map(holen));

console.log(`${ergebnisse.length} geholt`);
console.log(`Gedauert: etwa ${Math.round((performance.now() - start) / 100) * 100} ms`);

Den Unterschied macht [1, 2, 3, 4, 5].map(holen). Es ruft holen fünfmal auf, ohne dazwischen zu warten. Damit laufen fünf Vorgänge gleichzeitig, und Promise.all wartet einmal auf alle zusammen.

Das Ergebnis ist ein Array in derselben Reihenfolge wie die Eingabe. Welcher Vorgang zuerst fertig ist, spielt keine Rolle. Die Ergebnisse kommen in der Reihenfolge zurück, in der du sie hineingegeben hast.

Der Haken an Promise.all

Promise.all gilt ganz oder gar nicht.

Einer scheitert, alles scheitert
const holen = (nummer) =>
  nummer === 3
    ? Promise.reject(new Error("Datei 3 fehlt"))
    : Promise.resolve(`Datei ${nummer}`);

try {
  const ergebnisse = await Promise.all([1, 2, 3, 4, 5].map(holen));
  console.log(`${ergebnisse.length} geholt`);
} catch (fehler) {
  console.log(`Abgebrochen: ${fehler.message}`);
  console.log("Von den vier heilen Dateien ist nichts übrig.");
}

Sobald ein einziges Promise scheitert, wirft Promise.all sofort. Die vier anderen sind gelaufen oder laufen noch, aber an ihre Ergebnisse kommst du nicht mehr heran. Das Promise, das sie dir gegeben hätte, ist bereits im Fehlerzustand.

Wenn dein Programm ohne alle Teile ohnehin nicht weiterkann, ist das genau richtig. Wenn nicht, ist es ein Datenverlust auf Ansage.

allSettled, wenn jedes Ergebnis für sich zählt

allSettled behält jedes Ergebnis
const holen = (nummer) =>
  nummer === 3
    ? Promise.reject(new Error("Datei 3 fehlt"))
    : Promise.resolve(`Datei ${nummer}`);

const ergebnisse = await Promise.allSettled([1, 2, 3, 4, 5].map(holen));

for (const eintrag of ergebnisse) {
  console.log(
    eintrag.status === "fulfilled"
      ? `ok: ${eintrag.value}`
      : `fehlt: ${eintrag.reason.message}`,
  );
}

Promise.allSettled wartet ab, bis alle fertig sind, und wirft nie. Du bekommst für jedes ein Objekt, dessen status fulfilled oder rejected heißt, und dazu entweder ein value oder einen reason.

Der Preis ist, dass du die Ergebnisse selbst auseinandersortieren musst. Dafür verlierst du nichts.

Promise.race gibt dir das erste Ergebnis, egal ob Erfolg oder Fehler, und ist der übliche Weg für eine Zeitgrenze. Sein Geschwister Promise.any gibt dir das erste erfolgreiche und scheitert nur, wenn alle scheitern.

Wann nacheinander richtig ist

Gleichzeitig ist nicht immer besser. Nacheinander ist richtig, wenn der zweite Vorgang das Ergebnis des ersten braucht. Erst anmelden, dann mit dem Ergebnis der Anmeldung weiterarbeiten. Da hilft keine Gleichzeitigkeit.

Und es ist richtig, wenn die andere Seite nicht mehr verträgt. Eine fremde Schnittstelle mit einem Limit von zehn Anfragen pro Sekunde freut sich nicht über zweihundert auf einmal, und eine Datenbank mit zwanzig Verbindungen im Pool auch nicht.

„Alle gleichzeitig“ heißt bei fünftausend Dateien wirklich fünftausend gleichzeitig. Promise.all fragt nicht nach, ob das eine gute Idee ist. Es öffnet fünftausend Dateien auf einmal, und jede offene Datei belegt ein Dateihandle (englisch file handle). Ob das gut geht, hängt an einer Grenze des Betriebssystems für Dateihandles je Prozess. Node hebt sie beim Start selbst so weit an, wie das System es erlaubt. Liegt diese obere Grenze bei 1024, ist nach gut tausend Dateien Schluss, und in der Meldung steht EMFILE: too many open files. Wie hoch sie auf der Maschine liegt, auf der du gerade arbeitest, siehst du mit ulimit -Hn im Terminal.

Wo die Grenze liegt, hängt vom Fall ab. Bei einer festen, kleinen Liste nehme ich Promise.all oder allSettled, ohne nachzudenken. Bei einer Liste, deren Länge von außen kommt, denke ich kurz nach. Wie man eine Obergrenze von Hand baut, steht in Lektion 6.6.

In der Aufgabe sollen neun Kapitel gleichzeitig eingelesen werden, und eins davon gibt es nicht.

Zum Mitnehmen

Mit await in der Schleife addieren sich die Wartezeiten, mit Promise.all überlappen sie sich. Dafür nimmt bei Promise.all ein Fehlschlag die anderen Ergebnisse mit, und wer jedes Ergebnis für sich braucht, nimmt allSettled.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 4 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.