2. Fases do Event Loop

O Event Loop é organizado em fases, cada uma com um propósito específico. Entre as fases, o Node processa filas de tarefas microtask e, conforme a arquitetura, alterna entre a fila de microtarefas e as filas de macrotarefas. A ordem típica de etapas é a seguinte:

• Timers – callbacks programados com setTimeout e setInterval cuja hora de execução já chegou.
• Pending Callbacks – callbacks de operações de I/O pendentes que ainda não foram executados.
• Idle / DoEvents – estado ocioso; o loop fica pronto para entrar em operação de I/O.
• Poll – coleta de novos I/O; pode aguardar a chegada de novos eventos ou processar callbacks já prontos.
• Check – callbacks do setImmediate são executados aqui.
• Close Callbacks – callbacks de sockets fechados (por exemplo, ‘close’ em streams).

Observação prática: após cada fase, o motor processa a fila de microtarefas (microtasks) até ficar vazia, antes de retornar à próxima fase. Isso garante que Promises e outros runners assíncronos sejam tratados com prioridade previsível entre as fases.

3. Microtarefas vs Macrotarefas

Microtarefas são tarefas que precisam ser executadas o mais rápido possível, sem aguardar o próximo ciclo de loop. Exemplos comuns: Promise.then, catch e finally. Em Node.js, a fila especial process.nextTick é tratada de forma ligeiramente diferente: ela é executada imediatamente após a operação atual e antes de qualquer microtask, o que pode impactar a ordem de execução. Macrotarefas são as tarefas agendadas para acontecerem no próximo ciclo do Event Loop, como setTimeout, setInterval, setImmediate e callbacks de I/O.

Resumo prático: após a linha síncrona terminar, o Node processa process.nextTick, depois as microtarefas (Promise), e então avança para as fases do loop onde macrotarefas são executadas conforme o agendamento.

// Exemplo demonstrativo da ordem de execução
console.log('start');
setTimeout(() => console.log('timeout'), 0);
Promise.resolve().then(() => console.log('promise'));
process.nextTick(() => console.log('nextTick'));
console.log('end');
      

Saída típica (em Node.js):

start
end
nextTick
promise
timeout
      

Nesse exemplo, notamos que a linha síncrona finaliza antes de qualquer callback agendado, e os próximos passos mostram a ordem entre nextTick, microtarefas e timers. Esse tipo de diagrama ajuda a depurar impactos de encadeamentos assíncronos em código real.

4. Observações de desempenho e padrões

Para aplicações de alto desempenho, algumas práticas ajudam a evitar surpresas com o Event Loop:

• Evite bloquear a thread com código síncrono pesado. Divida tarefas longas entre worker_threads ou subprocessos quando necessário.
• Prefira operações de I/O assíncronas e uso adequado de streams para grandes volumes de dados.
• Use microtarefas com parcimônia; excessiva cadeia de Promises pode afetar a legibilidade e, em certos cenários, a latência.
• Considere o uso de setImmediate quando precisar que uma tarefa seja enfileirada após a fase de poll.
• Monitore o tempo de resposta e utilize ferramentas de instrumentação (console.time, perf hooks, tracing) para entender onde o loop está passando mais tempo.

Exemplo relevante

O snippet abaixo ilustra como o Event Loop processa Microtarefas vs Macrotarefas e ajuda a entender a ordem de execução em cenários reais:

// Exemplo completo de demonstração
(async () => {
  console.log('início');
  await new Promise(resolve => setTimeout(resolve, 0));
  console.log('após await');
})();
console.log('fim');
      

Observação: o fluxo real pode variar conforme o ambiente e o que está sendo executado no loop de eventos, mas esse tipo de padrão é comum em aplicações que dependem de encadeamentos assíncronos finos.