Abschnitt 6 · Lektion 2
Die Event Loop
Ein setTimeout, ein setImmediate, ein Promise und ein process.nextTick, alle in derselben
Funktion angemeldet, kommen in einer ganz anderen Reihenfolge dran, als sie im Code stehen. Kannst
du diese Reihenfolge nicht vorhersagen, suchst du später Fehler, die keine sind.
Node arbeitet in Runden. In jeder Runde schaut es nach, was inzwischen fertig geworden ist, und ruft die zugehörigen Callbacks auf. Diese Runde ist die Event Loop aus dem JavaScript-Kurs, auf Deutsch Ereignisschleife.
Die Reihenfolge
Zuerst läuft der synchrone Code. Komplett, bis zum Ende. Erst wenn dort nichts mehr zu tun ist, kommt überhaupt etwas anderes dran.
Dann leert Node zwei Warteschlangen, erst die von process.nextTick und danach die der
Mikrotasks (englisch microtasks). Mikrotasks sind aufgelöste Promises und alles, was mit
queueMicrotask angemeldet wurde.
Danach läuft die eigentliche Runde weiter. In Node hat sie mehrere Stationen (englisch phases). Für
den Alltag reichen zwei: die Timer (setTimeout, setInterval) und die Station danach, in der
setImmediate läuft. Dazwischen und drumherum werden die fertigen I/O-Rückmeldungen abgearbeitet,
also gelesene Dateien und angekommene Netzwerkantworten.
setTimeout(() => {
setTimeout(() => console.log("setTimeout nach 50 ms"), 50);
setImmediate(() => console.log("setImmediate"));
Promise.resolve().then(() => console.log("Promise-Mikrotask"));
process.nextTick(() => console.log("process.nextTick"));
console.log("synchron");
}, 0); Die Zeilen kommen genau umgekehrt dran, wie sie im Code stehen, die synchrone zuerst. Der
setTimeout steht oben und kommt zuletzt, denn seine 50 Millisekunden sind in dieser Runde noch
nicht um. Also ist die Station mit setImmediate vor ihm dran.
Der Sonderfall ganz oben in der Datei
Dieselben fünf Zeilen stehen hier nicht in einem Callback, sondern direkt am Anfang der Datei.
{
"name": "reihenfolge",
"version": "1.0.0",
"type": "module",
"private": true
} setTimeout(() => console.log("setTimeout nach 50 ms"), 50);
setImmediate(() => console.log("setImmediate"));
Promise.resolve().then(() => console.log("Promise-Mikrotask"));
process.nextTick(() => console.log("process.nextTick"));
console.log("synchron"); process.nextTick und der Mikrotask haben die Plätze getauscht. Alles andere steht gleich da.
Der Rumpf eines ES-Moduls läuft selbst schon in einem Promise. Deshalb darf dort ganz oben ein
await stehen, wie im Abschnitt über Module. Während deine Datei läuft, steckt Node also schon
mitten in der Abarbeitung der Mikrotasks. Was dort dazukommt, wird noch in derselben Runde mit
erledigt, und erst danach ist die nextTick-Warteschlange wieder an der Reihe.
Dass es hier ein Modul ist, liegt an "type": "module" in der package.json des Beispiels, dem
ersten der drei Wege aus Lektion 2.2. Ohne sie wäre oben.js eine ganz normale CommonJS-Datei. In
den fünf Zeilen steht nämlich nichts, woran Node ein Modul erkennen könnte, kein import, kein
export, kein await. Also greift auch der dritte Weg nicht, bei dem Node in die Datei schaut.
Dass es wirklich am Modul liegt, siehst du an derselben Datei mit der Endung .cjs, also als
CommonJS.
setTimeout(() => console.log("setTimeout nach 50 ms"), 50);
setImmediate(() => console.log("setImmediate"));
Promise.resolve().then(() => console.log("Promise-Mikrotask"));
process.nextTick(() => console.log("process.nextTick"));
console.log("synchron"); Da ist die gewohnte Reihenfolge wieder. Ein CommonJS-Modul wird synchron ausgeführt, ohne Promise drumherum. Damit gilt die normale Regel.
Wer beide Ausgaben untereinander haben will, legt im Terminal des Beispiels „Dieselben fünf Zeilen
ganz oben in der Datei“ mit cp oben.js oben.cjs die zweite Datei an. node oben.js und danach
node oben.cjs schreiben dann dieselben fünf Zeilen, die zweite und dritte vertauscht. Die Endung
ist der ganze Unterschied.
Die Reihenfolge hängt also davon ab, wo du etwas anmeldest. In einem Server läuft dein Code praktisch immer in einem Callback, und dann gilt die Regel aus dem ersten Beispiel.
Mikrotasks werden komplett abgeräumt
Node leert die Mikrotask-Warteschlange vollständig, auch mit den Einträgen, die beim Abarbeiten neu dazukommen.
setTimeout(() => console.log("Timer, angemeldet für 0 ms"), 0);
let kette = Promise.resolve();
for (let i = 1; i <= 4; i++) {
kette = kette.then(() => console.log(`Mikrotask ${i}`));
}
console.log("synchron"); Die Kette entsteht erst nach dem Timer mit seinen null Millisekunden und kommt trotzdem zuerst dran. Alle vier Glieder, hintereinander weg.
Eine Promise-Kette, die sich selbst immer wieder verlängert, kann die Event Loop deshalb am Weiterlaufen hindern. Das ist selten. Aber wenn es passiert, sucht man lange.
Was setTimeout(fn, 0) wirklich bedeutet
Die Null in setTimeout(fn, 0) heißt „bei nächster Gelegenheit, nach allem, was schon wartet“.
Vorher läuft der restliche synchrone Code, vorher werden nextTick und alle Mikrotasks abgeräumt,
und vorher wird alles erledigt, was in dieser Runde ohnehin dran ist.
Mit setTimeout(fn, 0) etwas ans Ende zu schieben, ist in Ordnung. Brauchst du es dagegen für eine
bestimmte Reihenfolge, stimmt fast immer an einer anderen Stelle etwas nicht.
Stehen setTimeout(fn, 0) und setImmediate beide auf oberster Ebene einer Datei, ist ihre
Reihenfolge nicht garantiert. Mal gewinnt der eine, mal der andere. Es kommt darauf an, ob seit
dem Anmelden schon eine Millisekunde vergangen ist, wenn Node die Runde betritt. Und das hängt am
Prozessstart. Deshalb steht in den Beispielen oben überall dort, wo auch ein setImmediate wartet,
ein Timer mit 50 Millisekunden.
Innerhalb eines I/O-Callbacks gewinnt dagegen immer setImmediate, weil seine Station in derselben
Runde noch kommt und die Timer-Station schon vorbei ist.
process.nextTick, der Sonderling
process.nextTick drängelt sich vor die Mikrotasks, und in fast allen Fällen brauchst du es nicht.
Auch seine Warteschlange leert Node komplett, bevor es irgendetwas anderes tut. Eine Funktion, die
sich am Ende selbst wieder per process.nextTick anmeldet, friert den Prozess deshalb wirklich ein.
Kein Timer läuft mehr, keine Anfrage wird mehr angenommen. Von außen sieht es aus wie ein Hänger,
dabei ist der Prozess voll beschäftigt.
setImmediate verhindert dieses Einfrieren, weil es in einer Station der Runde läuft und Timer und
Anfragen dazwischen drankommen. queueMicrotask hat denselben Haken wie process.nextTick, nur
eine Warteschlange später. Wenn ich etwas ans Ende des laufenden Codes schieben will, nehme ich
queueMicrotask, das gibt es auch im Browser. process.nextTick überlasse ich den Autoren von
Paketen.
In der Aufgabe stehen sechs Anmeldungen und eine synchrone Zeile in einem Callback von readFile,
jede mit einem Fragezeichen statt einer Nummer.
Zum Mitnehmen
In einem Callback kommt erst der synchrone Code, dann process.nextTick, dann die Mikrotasks und danach der Rest der Runde mit Timern und setImmediate. Ganz oben in einem ES-Modul tauschen nextTick und die Mikrotasks die Plätze.
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.