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.
Jede Iteration (« Tick ») durchläuft geordnete Phasen, jede mit ihrer eigenen Callback-Warteschlange:
┌───────────────────────────┐
┌─>│ timers (setTimeout) │ ← expired timer callbacks
│ ├───────────────────────────┤
│ │ pending I/O callbacks │
│ ├───────────────────────────┤
│ │ poll (I/O events) │ ← retrieve new I/O; execute their callbacks
│ ├───────────────────────────┤
│ │ check (setImmediate) │
│ ├───────────────────────────┤
└──│ close callbacks │
└───────────────────────────┘
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).
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.
// ❌ 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.
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.
Eine Sammlung von IT-Interviewfragen mit ausführlichen Antworten — vom Junior bis zum Senior.
Spenden