Czym jest event loop w Node.js i jak działa?

Question

Accepted Answer

**Event loop** to mechanizm, który pozwala Node.js działającemu na jednym wątku wykonywać **nieblokujące I/O**. Ciągle przetwarza kolejkę callbacków: podczas gdy Twój JavaScript działa na jednym wątku, operacje I/O są offloadowane, a ich callbacki są uruchamiane przez loop, gdy się zakończą.

## Fazy pętli

Każda iteracja ("tick") przechodzi przez uporządkowane fazy, każda z własną kolejką callbacków:

```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 uruchamiają się między fazami (wysoki priorytet)

```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żdej fazie (i po kodzie synchronicznym) Node opróżnia **microtasks**: callbacki `process.nextTick` najpierw, następnie callbacki Promise — *przed* przejściem dalej. Dlatego resolved Promise uruchamia się przed `setTimeout(…, 0)`.

## Dlaczego umożliwia współbieżność bez wątków

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

## Kardynalna reguła: nie blokuj pętli

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

Blokowanie jednego wątku zatrzymuje całą obsługę requestów. Offloaduj pracę intensywną CPU do worker threads.

## Dlaczego to ważne

Event loop to serce modelu wydajności Node — zrozumienie jego faz i priorytetu microtasks wyjaśnia async ordering, dlaczego Node obsługuje ogromną współbieżność na jednym wątku, i krytyczną regułę nigdy go nie blokować.

To fundamentalne dla napisania poprawnego, wydajnego kodu Node i do debugowania zaskakującego porządku wykonania async.