Noções Básicas do Event Loop

9 exemplos para você começar com o Event Loop - 6 básicos e 3 intermediários.

Pré-requisitos

• Node.js 24.18.0 instalado.
• Leia Como o Node.js Funciona para a visão geral de V8 + libuv.
• Novo no event loop? Comece com O Event Loop do Node.js para o modelo conceitual em que estes exemplos se baseiam.

Exemplos Básicos

1. Ordem da Call Stack

O código síncrono executa até a conclusão antes de qualquer callback agendado.

console.log('1');
console.log('2');
console.log('3');
// Saída: 1, 2, 3

• A call stack executa um frame por vez - ordem LIFO (Last-In, First-Out).
• Nada assíncrono é executado até que a stack esteja vazia.
• Funções síncronas longas atrasam todos os callbacks de I/O pendentes.

Relacionado: Como o Node.js Funciona - V8 e a thread única

2. setTimeout Agenda uma Macrotask

setTimeout não executa imediatamente - ele enfileira um callback para uma iteração posterior do loop.

console.log('start');
setTimeout(() => console.log('timeout'), 0);
console.log('end');
// start, end, timeout

• 0 ms é um atraso mínimo, não uma garantia - o loop precisa ser limpo primeiro.
• Timers executam na fase de timers do libuv.
• Trabalho síncrono pesado entre setTimeout e sua execução atrasa ainda mais o callback.

Relacionado: Timers e Agendamento - drift sob carga

3. Microtasks de Promise Executam Antes dos Timers

Microtasks (Promise .then) são esvaziadas antes da próxima macrotask.

console.log('A');
setTimeout(() => console.log('B'), 0);
Promise.resolve().then(() => console.log('C'));
console.log('D');
// A, D, C, B

• Promise.resolve().then agenda uma microtask na fila de microtasks.
• O Node esvazia todas as microtasks antes de passar para a próxima fase de macrotasks.
• Essa ordenação explica muitos bugs do tipo "por que X executou antes de Y?".

Relacionado: Microtasks vs Macrotasks - regras completas de ordenação

4. await Cede Controle ao Event Loop

await suspende a função assíncrona e retoma via microtasks.

async function demo(): Promise<void> {
  console.log('before');
  await Promise.resolve();
  console.log('after');
}
demo();
console.log('sync');
// before, sync, after

• O código após await é executado como uma continuação de microtask.
• Outras microtasks e código síncrono podem se intercalar antes de after.
• Cadeias de await aninhadas empilham microtasks - mantenha as cadeias rasas quando possível.

Relacionado: async/await no Node - padrões de tratamento de erros

5. Leitura de Arquivo Não Bloqueante

fs.promises agenda I/O no libuv e retorna o controle imediatamente.

import { readFile } from 'node:fs/promises';
 
console.log('before read');
readFile('package.json', 'utf8').then((data) => {
  console.log('read', data.length, 'bytes');
});
console.log('after read');

• O callback .then é executado após a leitura do arquivo ser concluída em uma thread em segundo plano.
• O JavaScript entre before e after é executado enquanto o I/O está em andamento.
• readFileSync bloquearia o loop - evite-o em caminhos de requisição.

6. setImmediate vs setTimeout(0)

setImmediate executa na fase de verificação (check), após a sondagem de I/O.

import { setImmediate } from 'node:timers';
 
setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));
// A ordem varia no nível superior; dentro de callbacks de I/O, immediate geralmente vence

• No nível superior do módulo, a ordem entre setTimeout(0) e setImmediate não é garantida.
• Dentro de um callback de I/O, setImmediate normalmente executa antes do próximo timer.
• Prefira queueMicrotask ou setImmediate em vez de setTimeout(fn, 0) para adiamento.

Relacionado: Fases do libuv - fases de timers, poll, check

Exemplos Intermediários

7. Bloqueando o Event Loop

Trabalho de CPU na thread principal paralisa todos os outros callbacks.

import { createServer } from 'node:http';
 
function block(ms: number): void {
  const end = Date.now() + ms;
  while (Date.now() < end) { /* spin */ }
}
 
createServer((req, res) => {
  if (req.url === '/block') block(3000);
  res.end('ok');
}).listen(3000);

• Enquanto block executa, nenhuma outra requisição progride neste processo.
• Testes de carga mostram picos de p99 mesmo quando a latência média parece boa.
• Descarregue trabalho de CPU para worker_threads ou uma fila de jobs.

Relacionado: Detectando Bloqueio do Event Loop - meça o lag em produção

8. Prioridade de process.nextTick

nextTick executa antes de outras microtasks - use com moderação.

Promise.resolve().then(() => console.log('promise'));
process.nextTick(() => console.log('nextTick'));
// nextTick, promise

• A fila nextTick é esvaziada antes das microtasks de Promise.
• nextTick recursivo pode "matar de fome" o I/O - nunca faça loop com nextTick.
• Prefira queueMicrotask para adiamento, a menos que você precise da semântica de nextTick.

Relacionado: Microtasks vs Macrotasks - ordenação de nextTick

9. Medir a Utilização do Event Loop

perf_hooks.eventLoopUtilization relata o quão ocupado o loop está.

import { eventLoopUtilization } from 'node:perf_hooks';
 
const start = eventLoopUtilization();
setInterval(() => {
  const elu = eventLoopUtilization(start);
  console.log('utilization:', elu.utilization.toFixed(3));
}, 5000);

• Utilização próxima a 1.0 significa que o loop está saturado - escale ou otimize.
• Combine com métricas de latência HTTP para correlacionar a dor do usuário com a saúde do loop.
• Exporte como um gauge Prometheus para alertas.

Relacionado: Melhores Práticas do Event Loop - regras operacionais

Versões da Stack: Esta página foi escrita para Node.js 24.18.0 (Active LTS), npm 10+, TypeScript 5.6+, Express 5, Fastify 5 e NestJS 11.