O que é o event loop em Node.js e como funciona?

Question

Accepted Answer

O **event loop** é o mecanismo que permite que Node.js de thread único execute **I/O não-bloqueante**. Ele processa continuamente uma fila de callbacks: enquanto seu JavaScript executa em um thread, operações de I/O são descarregadas, e seus callbacks são executados pelo loop quando completam.

## As fases do loop

Cada iteração ("tick") passa por fases ordenadas, cada uma com sua própria fila de 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 executam entre fases (alta prioridade)

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

Após cada fase (e após código síncrono), Node drena **microtasks**: callbacks `process.nextTick` primeiro, depois callbacks Promise — *antes* de prosseguir. É por isso que uma Promise resolvida executa antes de `setTimeout(…, 0)`.

## Por que permite concorrência sem threads

```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 regra cardinal: não bloqueie o loop

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

Bloqueiar o thread único interrompe todo o tratamento de requisições. Descarregue trabalho intensivo de CPU para worker threads.

## Por que isso importa

O event loop é o coração do modelo de desempenho do Node — entender suas fases e a prioridade de microtasks explica a ordenação async, por que Node lida com enorme concorrência em um thread, e a regra crítica de nunca bloqueá-lo.

É fundamental para escrever código Node correto e performático e para debugar ordem de execução async surpreendente.