Die Ereignisschleife ist ein Kernkonzept in Node.js, das die effiziente Abwicklung asynchroner Vorgänge ermöglicht. Hier ist eine vereinfachte Erklärung, wie es funktioniert:

1. Single-Threaded-Natur

Node.js arbeitet auf einem einzelnen Thread. Das bedeutet, dass jeweils nur ein Teil des Codes ausgeführt werden kann. Node.js ist jedoch darauf ausgelegt, viele Vorgänge gleichzeitig abzuwickeln, ohne dass mehrere Threads erforderlich sind.

2. Nicht blockierende E/A

Node.js verwendet nicht blockierende E/A-Vorgänge. Wenn Node.js Aufgaben wie das Lesen von Dateien, das Abfragen einer Datenbank oder das Stellen von Netzwerkanfragen ausführt, wartet es nicht, bis diese Aufgaben abgeschlossen sind, bevor es mit der nächsten Aufgabe fortfährt. Stattdessen führt es weiterhin anderen Code aus, während diese Aufgaben verarbeitet werden.

3. Ereignisschleifenmechanismus

Die Ereignisschleife ist für die Verwaltung der Codeausführung und die Behandlung asynchroner Ereignisse verantwortlich. Es überprüft kontinuierlich die „Warteschlange“ der Aufgaben und entscheidet, welche ausgeführt werden sollen. Hier ist eine Schritt-für-Schritt-Anleitung:

• Initialisieren: Wenn eine Node.js-Anwendung startet, initialisiert sie die Umgebung und richtet sie ein.
• Ausführungsphase: Node.js führt jeden anfänglichen Code synchron aus. Wenn es asynchrone Aufgaben gibt (wie das Lesen von Dateien oder HTTP-Anfragen), werden diese an die APIs des Systems übergeben.
• Ereignisschleifenphasen: Die Ereignisschleife hat mehrere Phasen und verarbeitet Aufgaben in jeder Phase in einer bestimmten Reihenfolge:
  • Timer-Phase: Führt von setTimeout() und setInterval() geplante Rückrufe aus.
  • IO-Rückrufphase: Führt Rückrufe für E/A-Vorgänge aus, z. B. Dateilesevorgänge oder Netzwerkanforderungen.
  • Leerlauf, Vorbereitungsphase: Interne Phase, die für Systemaufgaben verwendet wird.
  • Abfragephase: Ruft neue E/A-Ereignisse ab und führt deren Rückrufe aus. Wenn die Umfragewarteschlange leer ist, wird geprüft, ob Rückrufe in der setImmediate()-Warteschlange vorhanden sind.
  • Prüfphase: Führt von setImmediate() geplante Rückrufe aus.
  • Close Callbacks Phase: Behandelt Close-Ereignisse, wie sie beispielsweise von socket.on('close') ausgegeben werden.
• Erneut prüfen und beenden: Wenn die Ereignisschleife keine weiteren Aufgaben mehr zu verarbeiten hat, wird sie beendet, sodass das Programm beendet werden kann. Wenn noch Aufgaben ausstehen, wird die Ausführung fortgesetzt.

4. Rückrufwarteschlange

Asynchrone Aufgaben schieben ihre Rückrufe nach Abschluss in eine Warteschlange. Die Ereignisschleife wählt diese Rückrufe aus der Warteschlange aus und führt sie der Reihe nach aus.

5. Mikrotask-Warteschlange (nächstes Häkchen)

Neben der Hauptwarteschlange gibt es auch eine Mikrotask-Warteschlange (oder Next-Tick-Warteschlange), in der mit Process.nextTick() oder Promises‘ .then()-Handlern geplante Rückrufe in die Warteschlange gestellt werden. Mikrotasks haben Vorrang vor regulären Rückrufen, d. h. sie werden ausgeführt, nachdem der aktuelle Vorgang abgeschlossen ist, aber bevor die Ereignisschleife in die nächste Phase übergeht.

Beispiel

Hier ist ein einfaches Beispiel, um zu veranschaulichen, wie die Ereignisschleife funktioniert:

const fs = require('fs');

console.log('Start');

fs.readFile('file.txt', (err, data) => {
  if (err) throw err;
  console.log('File read complete');
});

console.log('End');

Ausgabe:

Start
End
File read complete

Erläuterung:

1. console.log('Start'); und console.log('End'); werden synchron ausgeführt.
2. fs.readFile initiiert einen asynchronen Dateilesevorgang und fährt mit der Ausführung der nächsten Codezeile fort, ohne zu warten.
3. Sobald der Dateilesevorgang abgeschlossen ist, wird sein Rückruf (console.log('File read abgeschlossen');) in die Rückrufwarteschlange der Ereignisschleife verschoben.
4. Die Ereignisschleife verarbeitet den Rückruf, nachdem die synchrone Codeausführung abgeschlossen ist.

Die Ereignisschleife ermöglicht es Node.js, trotz Single-Threading viele Vorgänge gleichzeitig effizient abzuwickeln, indem Vorgänge an das System delegiert und ihre Ergebnisse asynchron verarbeitet werden.

Die Ereignisschleife orchestriert die Ausführung von Aufgaben und priorisiert die Mikrotask-Warteschlange, um sicherzustellen, dass Versprechen und zugehörige Vorgänge schnell gelöst werden, bevor mit Aufgaben in der Hauptaufgabenwarteschlange fortgefahren wird (Makroaufgabe).

Diese Dynamik ermöglicht es JavaScript, komplexes asynchrones Verhalten in einer Single-Threaded-Umgebung zu verarbeiten.