Node.js: Programação Assíncrona

Última atualização: 2026-08-26

1. Relato: Um serviço bloqueado por 200 ms

O serviço de API do Bob normalmente responde em apenas 5 ms, mas durante os horários de pico, os tempos de resposta dispararam para 2.000 ms. Os usuários não paravam de reclamar e, a princípio, ele achou que o banco de dados estava lento, mas adicionar índices não adiantou. Mais tarde, usando o console.time para solucionar o problema passo a passo, ele descobriu que a classificação de um grande array JSON síncrono estava levando 200 ms — essa operação de 200 ms estava bloqueando o loop de eventos, fazendo com que todas as solicitações na fila ficassem aguardando sua conclusão. Depois de entender como o loop de eventos funciona, Bob usou setImmediate para dividir a classificação em partes menores e executá-las uma a uma, reduzindo os tempos de resposta durante os horários de pico para 50 ms.

Você vai aprender:

• Responsabilidades e fluxo das 6 fases do ciclo de eventos
• Prioridade da fila de microtarefas (process.nextTick / Promise.then)
• Agendamento de filas de tarefas macro (setTimeout / setImmediate / E/S)
• setTimeout x setImmediate x ordem de execução do process.nextTick
• Por que setImmediate tem prioridade sobre setTimeout em um contexto de E/S
• Os riscos de bloquear o ciclo de eventos e estratégias para dividi-lo

2. As 6 etapas do ciclo de eventos

O ciclo de eventos do Node.js é controlado pela libuv e passa por seis fases em sequência. Cada ciclo começa com os “temporizadores” e termina com os “callbacks de encerramento”, retornando então aos “temporizadores” para iniciar o próximo ciclo.

flowchart TD
    A["timers<br/>setTimeout / setInterval"] --> B["pending callbacks<br/>System-Level Callbacks"]
    B --> C["idle, prepare<br/>For internal use only"]
    C --> D["poll<br/>I/O callbacks / new I/O polling"]
    D --> E["check<br/>setImmediate"]
    E --> F["close callbacks<br/>socket.on('close')"]
    F --> A

flowchart TD
    A["timers<br/>setTimeout / setInterval"] --> B["pending callbacks<br/>System-Level Callbacks"]
    B --> C["idle, prepare<br/>For internal use only"]
    C --> D["poll<br/>I/O callbacks / new I/O polling"]
    D --> E["check<br/>setImmediate"]
    E --> F["close callbacks<br/>socket.on('close')"]
    F --> A

3. Microtarefas e macrotarefas

(1) (3.1) Fila de microtarefas

As microtarefas são executadas na íntegra após o término da fase atual e antes do início da próxima fase. A fila de microtarefas possui dois níveis de prioridade:

▶ Exemplo: nextTick tem precedência sobre Promise.then

process.nextTick(() => {
  console.log('nextTick 1');
});

Promise.resolve().then(() => {
  console.log('promise.then 1');
});

process.nextTick(() => {
  console.log('nextTick 2');
});

Promise.resolve().then(() => {
  console.log('promise.then 2');
});

nextTick 1
nextTick 2
promise.then 1
promise.then 2

(2) (3.2) Fila de macrotarefas

As macrotarefas são agendadas por cada fase do ciclo de eventos, sendo que cada fase executa suas macrotarefas correspondentes.

4. setTimeout x setImmediate x process.nextTick

▶ Exemplo: A ordem de execução dos contextos externos é indefinida

setTimeout(() => {
  console.log('setTimeout');
}, 0);

setImmediate(() => {
  console.log('setImmediate');
});

Em um contexto que não envolva E/S, a ordem de execução de setTimeout e setImmediate é indefinida — ela depende do agendamento de processos do sistema, e qualquer uma delas pode ser executada primeiro.

▶ Exemplo: Em um contexto de E/S, setImmediate é sempre executado primeiro

const fs = require('fs');

fs.readFile(__filename, () => {
  setTimeout(() => {
    console.log('setTimeout');
  }, 0);

  setImmediate(() => {
    console.log('setImmediate');
  });
});

setImmediate
setTimeout

Os callbacks de E/S são executados durante a fase de sondagem; assim que são concluídos, o processo passa para a fase de verificação (setImmediate) e só então avança para a próxima rodada da fase dos temporizadores (setTimeout).

▶ Exemplo: process.nextTick sempre vem primeiro

setTimeout(() => {
  console.log('setTimeout');
}, 0);

setImmediate(() => {
  console.log('setImmediate');
});

process.nextTick(() => {
  console.log('nextTick');
});

nextTick
setTimeout   (or setImmediate, depends on scheduling)
setImmediate

5. Comparação entre microtarefas e macrotarefas

▶ Exemplo: Microtarefas intercaladas entre macrotarefas

setTimeout(() => {
  console.log('timeout 1');
  Promise.resolve().then(() => {
    console.log('promise between 1 and 2');
  });
}, 0);

setTimeout(() => {
  console.log('timeout 2');
}, 0);

timeout 1
promise between 1 and 2
timeout 2

Após a conclusão de cada macro-tarefa, a fila de micro-tarefas é esvaziada antes da execução da próxima macro-tarefa.

6. Os riscos de bloquear o ciclo de eventos e como evitá-los

▶ Exemplo: Bloqueando o ciclo de eventos

const http = require('http');

const server = http.createServer((req, res) => {
  const start = Date.now();
  while (Date.now() - start < 200) {}
  res.end('done');
});

server.listen(3000, () => {
  console.log('Server running on port 3000');
});

Cada solicitação bloqueia o ciclo de eventos por 200 ms; durante esse tempo, nenhuma outra solicitação pode ser processada.

▶ Exemplo: Dividindo tarefas de longa duração com setImmediate

function chunkedSort(arr, compareFn, callback) {
  const CHUNK = 1000;
  let offset = 0;

  function sortChunk() {
    const end = Math.min(offset + CHUNK, arr.length);
    for (let i = offset; i < end; i++) {
      for (let j = i + 1; j < end; j++) {
        if (compareFn(arr[i], arr[j]) > 0) {
          [arr[i], arr[j]] = [arr[j], arr[i]];
        }
      }
    }
    offset = end;
    if (offset < arr.length) {
      setImmediate(sortChunk);
    } else {
      callback(arr);
    }
  }

  setImmediate(sortChunk);
}

chunkedSort(
  [5, 3, 8, 1, 9, 2, 7, 4, 6],
  (a, b) => a - b,
  (result) => {
    console.log('Sorted:', result);
  }
);

7. Exemplo completo: script para verificar a ordem de execução do ciclo de eventos

O script a seguir verifica a ordem completa de execução de setTimeout → process.nextTick → setImmediate → Promise.then → callback de E/S.

const fs = require('fs');

console.log('--- Script start ---');

setTimeout(() => {
  console.log('1. setTimeout (macrotask - timers)');
}, 0);

setImmediate(() => {
  console.log('2. setImmediate (macrotask - check)');
});

process.nextTick(() => {
  console.log('3. process.nextTick (microtask - highest)');
});

Promise.resolve().then(() => {
  console.log('4. Promise.then (microtask)');
});

fs.readFile(__filename, () => {
  console.log('5. I/O callback (poll phase)');

  setTimeout(() => {
    console.log('6.   inner setTimeout');
  }, 0);

  setImmediate(() => {
    console.log('7.   inner setImmediate');
  });

  process.nextTick(() => {
    console.log('8.   inner nextTick');
  });

  Promise.resolve().then(() => {
    console.log('9.   inner Promise.then');
  });
});

console.log('--- Script end ---');

--- Script start ---
--- Script end ---
3. process.nextTick (microtask - highest)
4. Promise.then (microtask)
1. setTimeout (macrotask - timers)
2. setImmediate (macrotask - check)
5. I/O callback (poll phase)
8.   inner nextTick
9.   inner Promise.then
7.   inner setImmediate
6.   inner setTimeout

Análise da ordem de execução:

1. O código síncrono é executado primeiro, exibindo “Início do script” e “Fim do script”
2. Limpar as microtarefas após o término da fase atual: nextTick → Promise.then
3. Entre na fase dos “temporizadores”: setTimeout
4. Entrar na fase de verificação: setImmediate
5. Executar a função de retorno de chamada durante a fase de sondagem, após a conclusão da E/S
6. Limpe a microtarefa após a conclusão do callback de E/S: inner nextTick → inner Promise.then
7. Quando a enquete terminar, insira o comando: inner setImmediate
8. Próxima rodada de temporizadores: setTimeout interno

❓ Perguntas Frequentes

P: O setTimeout(fn, 0) realmente é executado após 0 ms? R: Não. Tanto os navegadores quanto o Node.js têm um atraso mínimo (aproximadamente 1 ms), e a execução precisa aguardar até que o ciclo de eventos entre na fase “timers”; o tempo de espera real depende da fase atual.

P: Qual é executado primeiro, process.nextTick ou Promise.then? R: process.nextTick é executado primeiro. nextTick tem a prioridade mais alta na fila de microtarefas, e a fila nextTick é sempre esvaziada antes da fila de Promises.

P: Por que setImmediate é executado antes de setTimeout em um callback de E/S? R: Os callbacks de E/S são executados durante a fase poll. Assim que essa fase termina, o processo passa diretamente para a fase check (setImmediate) antes de prosseguir para a próxima rodada da fase timers (setTimeout). Portanto, em um contexto de E/S, setImmediate sempre é executado antes de setTimeout.

P: O ciclo de eventos é de thread único ou multithread? R: A execução do JavaScript é de thread único, mas a libuv subjacente possui um pool de threads (4 threads por padrão) que lida com operações como consultas de DNS e E/S de arquivos. A E/S de rede é tratada pelo kernel do sistema operacional, que notifica o ciclo de eventos assim que a operação é concluída.

P: Como evitar bloquear o ciclo de eventos? R: Divida cálculos longos em partes menores e execute-os passo a passo usando setImmediate; utilize threads de trabalho para transferir tarefas que exigem muito da CPU para threads separadas; use E/S assíncrona em vez de E/S síncrona; e utilize fluxos para processar grandes conjuntos de dados em partes.

P: É possível chamar process.nextTick recursivamente de forma indefinida? R: Isso não é recomendado. O Node.js possui um limite padrão definido por process.maxTickDepth; chamadas recursivas a nextTick impedirão que o ciclo de eventos entre na próxima fase, levando à escassez de E/S. Você deve usar setImmediate em vez de chamadas recursivas de nextTick.

📖 Resumo

• Matéria: Os conceitos fundamentais e o uso de um serviço bloqueado por 200 ms
• Conceitos-chave e uso das 6 fases do ciclo de eventos
• Conceitos básicos e uso de microtarefas e macrotarefas
• Conceitos-chave e uso de setTimeout, setImmediate e process.nextTick
• Conceitos-chave e uso de microtarefas versus macrotarefas
• Os riscos de bloquear o loop de eventos, conceitos-chave para evitá-lo e como fazê-lo
• Exemplo abrangente: Verificação da ordem de execução do ciclo de eventos — Conceitos básicos e uso de scripts

📝 Exercícios

1. Conclua todos os exemplos de código desta lição e certifique-se de que cada um deles seja executado corretamente.
2. Modifique o exemplo completo e adicione suas próprias extensões
3. Analise a documentação oficial, identifique 1 ou 2 APIs que não foram abordadas nesta aula e escreva um código de teste para elas.
4. Reflexão: Como você aplicaria o que aprendeu nesta aula a um projeto do mundo real?
5. Tente combinar o que você aprendeu nesta aula com o conteúdo das aulas anteriores para criar um pequeno projeto.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós