Abschnitt 6 · Lektion 4
Parallel oder nacheinander
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
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
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.
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
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, kostenlosZu 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.