Vad är event loop i Node.js och hur fungerar det?

Question

IT Interview Practice · Accepted Answer

**Event loop** är mekanismen som låter enkeltrådig Node.js utföra **icke-blockerande I/O**. Den bearbetar kontinuerligt en kö av callbacks: medan din JavaScript körs på en tråd offloaderas I/O-operationerna, och deras callbacks körs av loopen när de slutförs.

## Slingans faser

Varje iteration ("tick") går igenom ordnade faser, var och en 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örs mellan faser (hög 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 varje fas (och efter synkron kod) tömmer Node **microtasks**: `process.nextTick` callbacks först, sedan Promise callbacks — *innan* att fortsätta. Det är därför ett löst Promise körs före `setTimeout(…, 0)`.

## Varför det möjliggör samtidighet utan trådar

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

## Huvudregeln: blockera inte slingen

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

Att blockera den enda tråden stoppar all begäranhantering. Offloadera CPU-intensivt arbete till worker threads.

## Varför det spelar roll

Event loop är hjärtat i Nodes prestandamodell — att förstå dess faser och microtask-prioritet förklarar async-ordning, varför Node hanterar massiv samtidighet på en tråd, och den kritiska regeln att aldrig blockera den.

Det är fundamentalt för att skriva korrekt, performant Node-kod och för att debugga överraskande asynk-exekveringsordning.

Slingans faser

Microtasks körs mellan faser (hög prioritet)

Varför det möjliggör samtidighet utan trådar

Huvudregeln: blockera inte slingen

Varför det spelar roll

Relaterade frågor