Ce este event loop-ul în Node.js și cum funcționează?

Question

Accepted Answer

**Event loop-ul** este mecanismul care permite Node.js single-threaded să efectueze **I/O non-blocare**. El procesează continuu o coadă de callbacks: în timp ce JavaScript-ul dvs. rulează pe un thread, operațiile I/O sunt descărcate, iar callback-urile lor sunt rulate de loop atunci când se completează.

## Fazele buclei

Fiecare iterație ("tick") se mișcă prin faze ordonate, fiecare cu propria sa coadă de callback:

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

## Microtask-urile rulează între faze (prioritate ridicată)

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

După fiecare fază (și după cod sincron), Node golește **microtask-urile**: callback-urile `process.nextTick` mai întâi, apoi callback-urile Promise — *înainte* de a merge mai departe. De aceea o Promise rezolvată rulează înainte de `setTimeout(…, 0)`.

## De ce permite concurență fără thread-uri

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

## Regula cardinală: nu bloca buclă

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

Blocherea thread-ului unic oprește toată procesarea solicitărilor. Descărcați munca intensivă CPU pentru worker threads.

## De ce contează

Event loop-ul este inima modelului de performanță al Node — înțelegerea fazelor sale și prioritatea microtask explică ordenarea async, de ce Node gestionează concurență imensă pe un thread, și regula critică de a nu-l bloca niciodată.

Este fundamental pentru scrierea codului Node corect și performant și pentru debugging-ul ordinii de execuție async surprinzătoare.