Mi az event loop a Node.js-ben és hogyan működik?

Question

IT Interview Practice · Accepted Answer

Az **event loop** az a mechanizmus, amely lehetővé teszi, hogy az egyszálú Node.js végezzen **non-blocking I/O**-t. Folyamatosan feldolgoz egy callback-sor: miközben a JavaScript egy szálon fut, az I/O operációk kiszervezésre kerülnek, és azok callback-jeit a loop hajtja végre, amikor befejeződnek.

## A petze fázisai

Minden iteráció ("tick") rendezett fázisokon megy keresztül, mindegyiknek van saját callback-sora:

```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         │
   └───────────────────────────┘
```

## A microtask-ok a fázisok között futnak (magas prioritás)

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

Minden fázis után (és a szinkron kód után) a Node kiüríti a **microtask-okat**: először a `process.nextTick` callback-ek, majd a Promise callback-ek — *mielőtt* továbblépne. Ez az oka annak, hogy egy feloldott Promise a `setTimeout(…, 0)` előtt fut.

## Hogyan tesz lehetővé egyidejűséget szálak nélkül

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

## A bíborít szabály: ne blokkold a petét

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

Az egyetlen szál blokkolása leállítja az összes kérelem kezelést. Az CPU-igényes munkát dolgozó szálakra kell kiszervezni.

## Miért fontos

Az event loop a Node teljesítményi modell szíve — fázisainak és a microtask prioritásának megértése megmagyarázza az async sorrendet, miért kezeli a Node hatalmas egyidejűséget egy szálon, és azt a kritikus szabályt, hogy soha ne blokkolja.

Ez alapvető a helyes, performáns Node kód írásához és a meglepő async végrehajtási sorrend debuggolásához.

A petze fázisai

A microtask-ok a fázisok között futnak (magas prioritás)

Hogyan tesz lehetővé egyidejűséget szálak nélkül

A bíborít szabály: ne blokkold a petét

Miért fontos

Kapcsolódó kérdések