Was ist die Event Loop in Node.js und wie funktioniert sie?

Question

Accepted Answer

Die **Event Loop** ist der Mechanismus, der es dem **single-threaded** Node.js ermöglicht, **nicht-blockierende I/O** durchzuführen. Sie verarbeitet kontinuierlich eine Warteschlange von Callbacks: Während Ihr JavaScript auf einem einzigen Thread läuft, werden I/O-Operationen ausgelagert, und ihre Callbacks werden von der Schleife ausgeführt, wenn sie abgeschlossen sind.

## Die Phasen der Schleife

Jede Iteration (« Tick ») durchläuft geordnete Phasen, jede mit ihrer eigenen Callback-Warteschlange:

```text
   ┌───────────────────────────┐
┌─>│   timers (setTimeout)     │  ← expired timer callbacks
│  ├───────────────────────────┤
│  │   pending I/O callbacks   │
│  ├───────────────────────────┤
│  │   poll (I/O events)       │  ← retrieve new I/O; execute their callbacks
│  ├───────────────────────────┤
│  │   check (setImmediate)    │
│  ├───────────────────────────┤
└──│   close callbacks         │
   └───────────────────────────┘
```

## Microtasks laufen zwischen Phasen ab (höchste Priorität)

```js
console.log("1");                          // sync
setTimeout(() => console.log("2"), 0);     // timers phase (macrotask)
setImmediate(() => console.log("3"));      // check phase
Promise.resolve().then(() => console.log("4")); // microtask
process.nextTick(() => console.log("5"));  // nextTick — highest priority
console.log("6");
// Output: 1, 6, 5, 4, 2/3 (timer vs immediate order can vary)
```

Nach jeder Phase (und nach synchronem Code) leert Node die **Microtasks**: zuerst `process.nextTick`-Callbacks, dann Promise-Callbacks — *bevor* es weitermacht. Deshalb läuft eine aufgelöste Promise vor `setTimeout(…, 0)`.

## Warum dies Nebenläufigkeit ohne Threads ermöglicht

```text
A DB query or file read is handed to the OS/thread pool → Node keeps running
other code → when the result is ready, its callback is queued → the loop runs it.
One thread, thousands of in-flight operations.
```

## Die oberste Regel: Blockieren Sie nicht die Schleife

```js
// ❌ a long synchronous loop freezes EVERYTHING — no other callback can run
while (Date.now() - start < 5000) {}
```

Das Blockieren des einzelnen Threads stoppt die gesamte Request-Verarbeitung. Lagern Sie CPU-intensive Arbeiten an Worker Threads aus.

## Warum es wichtig ist

Die Event Loop ist das Herzstück von Nodes Performance-Modell — das Verständnis ihrer Phasen und der Microtask-Priorität erklärt die asynchrone Ausführungsreihenfolge, warum Node massive Nebenläufigkeit auf einem Thread bewältigt, und die kritische Regel, sie niemals zu blockieren.

Es ist grundlegend für das Schreiben von korrektem, performantem Node-Code und für das Debuggen überraschender asynchroner Ausführungsreihenfolge.