Co je event loop v Node.js a jak funguje?

Question

IT Interview Practice · Accepted Answer

**event loop** je mechanismus, který umožňuje jednovláknému Node.js provádět **non-blocking I/O**. Nepřetržitě zpracovává frontu callbacks: zatímco váš JavaScript běží na jednom vlákně, I/O operace jsou odsunuta a jejich callbacks jsou spuštěny smyčkou po dokončení.

## Fáze smyčky

Každá iterace ("tick") prochází seřazenými fázemi, každá se svou vlastní frontou callbacks:

```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 běží mezi fázemi (vysoká priorita)

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

Po každé fázi (a po synchronním kódu) Node vyprazdňuje **microtasks**: nejdříve `process.nextTick` callbacks, pak Promise callbacks — *před* pokračováním. To je důvod, proč se resolved Promise spustí dříve než `setTimeout(…, 0)`.

## Proč to umožňuje souběh bez vláken

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

## Základní pravidlo: neblokujte smyčku

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

Blokování jednoho vlákna zastaví veškeré zpracování požadavků. Přeneste CPU-intenzivní práci do worker threads.

## Proč je to důležité

Event loop je srdcem Node.js modelu výkonu — pochopení jeho fází a priority microtask vysvětluje async pořadí, proč Node zvládá obrovský souběh na jednom vlákně a kritické pravidlo, aby ji nikdy neblokovalo.

Je to základní pro psaní správného a efektivního Node kódu a pro debug překvapivého async pořadí spuštění.

Fáze smyčky

Microtasks běží mezi fázemi (vysoká priorita)

Proč to umožňuje souběh bez vláken

Základní pravidlo: neblokujte smyčku

Proč je to důležité

Související otázky