mitmario.dev

Die Event Loop

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

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.

Die Runde von innen gesehen
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.

Dieselben fünf Zeilen ganz oben in der Datei
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.

Und dieselbe Datei 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.

Mikrotasks räumen komplett ab
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, 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.