Microtasks vs Macrotasks

O Node.js agenda trabalho assíncrono em duas famílias de filas - microtasks (Promises, queueMicrotask, process.nextTick) e macrotasks (timers, setImmediate) - e a ordem de esgotamento explica bugs sutis de timing.

Receita

Tabela de referência de ordenação (simplificada):

1. Executa a call stack até ficar vazia
2. Esgota TODAS as callbacks de process.nextTick
3. Esgota TODAS as microtasks (Promises, queueMicrotask)
4. Executa UMA macrotask (timer, I/O, setImmediate, ...)
5. Repete a partir do passo 2

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

Quando usar isso:

• Quebra-cabeças de ordenação estilo entrevista em código de produção
• Depurando "execução dupla" após await
• Escolhendo entre nextTick, queueMicrotask e setImmediate
• Prevenindo starvation de I/O de adiamento recursivo

Exemplo de Trabalho

import { setTimeout, setImmediate } from 'node:timers';
 
async function chain(): Promise<void> {
  console.log('A');
  await Promise.resolve();
  console.log('B');
}
 
chain();
Promise.resolve().then(() => console.log('C'));
process.nextTick(() => console.log('D'));
setTimeout(() => console.log('E'), 0);
console.log('F');
// A, F, D, C, B, E (B pode intercalar com C dependendo do timing do await)

// Perigoso: nextTick recursivo causa starvation de I/O
function spin(count: number): void {
  if (count <= 0) return;
  process.nextTick(() => spin(count - 1));
}
// spin(1_000_000); // Nunca faça isso em produção

O que isso demonstra:

• Código síncrono (A, F) é executado antes de qualquer trabalho assíncrono enfileirado
• nextTick precede as microtasks de Promise
• await divide funções assíncronas em continuações de microtask
• nextTick recursivo impede que macrotasks (incluindo I/O) sejam executadas

Mergulho Profundo

Como Funciona

• Macrotasks mapeiam para fases do libuv: timers, callbacks de I/O, setImmediate, etc.
• Microtasks são uma fila interna processada após cada macrotask (e após o código síncrono).
• process.nextTick é tecnicamente separado da fila de microtasks de Promise, mas é executado antes dela.
• queueMicrotask agenda microtasks compatíveis com o padrão - prefira-o em vez de nextTick para adiamento genérico.

Comparação de Filas

Notas de TypeScript

// Adia de forma segura - não preempte a fila de Promises como nextTick
function defer(fn: () => void): void {
  queueMicrotask(fn);
}
 
// Executa após o lote de I/O atual, não antes de outras microtasks
import { setImmediate } from 'node:timers';
function deferMacrotask(fn: () => void): void {
  setImmediate(fn);
}

Armadilhas

• process.nextTick recursivo - causa starvation de timers e I/O indefinidamente. Correção: use setImmediate para lotes ou um worker.
• Assumir que await torna o código "paralelo" - ele apenas cede microtasks na mesma thread. Correção: use workers para paralelismo de CPU.
• Misturar nextTick com cadeias de Promises para hacks de ordenação - frágil entre versões do Node. Correção: reestruture com máquinas de estado explícitas ou filas.
• Rejeições não tratadas em microtasks - travam o processo se não forem capturadas antes da próxima macrotask. Correção: sempre use try/catch em torno de await em manipuladores de eventos.
• Registrar a ordem de microtasks em produção - bugs de ordem são problemas de tempo de desenvolvimento; produção precisa de métricas. Correção: corrija a arquitetura, não confie na ordenação de logs.

Alternativas

FAQs

Relacionado

• Fases do libuv - de onde vêm as macrotasks
• async/await no Node - padrões assíncronos práticos
• Noções Básicas do Event Loop - primeiros exemplos de ordenação
• Detectando Bloqueio do Event Loop - sintomas de starvation

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.