Hvad er event loop i Node.js, og hvordan fungerer det?

Question

IT Interview Practice · Accepted Answer

**event loop** er mekanismen, der lader single-threaded Node.js udføre **non-blocking I/O**. Det behandler løbende en kø af callbacks: mens dit JavaScript kører på én tråd, udliciteres I/O-operationer, og deres callbacks køres af løkken når de afsluttes.

## Løkkens faser

Hver iteration ("tick") gennemløber ordnede faser, hver med sin egen callback-kø:

```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 kører mellem faser (høj prioritet)

```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)
```

Efter hver fase (og efter synkron kode) dræner Node **microtasks**: `process.nextTick` callbacks først, derefter Promise callbacks — *før* fortsættelse. Det er derfor et opløst Promise køres før `setTimeout(…, 0)`.

## Hvorfor det muliggør samtidighed uden tråde

```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.
```

## Kardinalreglen: bloker ikke løkken

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

Blokeringen af den enkelte tråd standsede hele anmodningsbehandlingen. Aflaster CPU-tung arbejde til worker threads.

## Hvorfor det betyder noget

Event loop er hjerte af Node.js' ydelsemodel — forståelse af dens faser og microtask-prioritet forklarer async-rækkefølge, hvorfor Node håndterer stor samtidighed på én tråd, og den kritiske regel aldrig at blokere det.

Det er fundamentalt for at skrive korrekt, effektivt Node-kode og for at debugge overraskende async-eksekveringsrækkefølge.

Løkkens faser

Microtasks kører mellem faser (høj prioritet)

Hvorfor det muliggør samtidighed uden tråde

Kardinalreglen: bloker ikke løkken

Hvorfor det betyder noget

Relaterede spørgsmål