Che cos'è l'event loop in Node.js e come funziona?

Question

Accepted Answer

L'**event loop** è il meccanismo che consente a Node.js single-threaded di eseguire **non-blocking I/O**. Elabora continuamente una coda di callback: mentre il tuo JavaScript viene eseguito su un thread, le operazioni I/O vengono scaricate, e i loro callback vengono eseguiti dal loop quando completano.

## Le fasi del loop

Ogni iterazione ("tick") si muove attraverso fasi ordinate, ognuna con la propria coda di 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         │
   └───────────────────────────┘
```

## I microtask vengono eseguiti tra le fasi (alta priorità)

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

Dopo ogni fase (e dopo il codice sincrono), Node svuota i **microtask**: prima i callback di `process.nextTick`, poi i callback Promise — *prima* di continuare. Per questo motivo una Promise risolta viene eseguita prima di `setTimeout(…, 0)`.

## Perché consente concorrenza senza thread

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

## La regola cardinale: non bloccare il loop

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

Bloccare il thread unico arresta tutta la gestione delle richieste. Affida il lavoro CPU-intensive ai worker thread.

## Perché è importante

L'event loop è il cuore del modello di performance di Node — comprendere le sue fasi e la priorità dei microtask spiega l'ordine async, perché Node gestisce un'enorme concorrenza su un thread, e la regola critica di non bloccarlo mai.

È fondamentale per scrivere codice Node corretto e performante e per debuggare sorprendenti ordini di esecuzione asincrona.