Event loop do JavaScript

Pilha de chamadas, microtarefas e tarefas: por que um código assíncrono roda na ordem que roda.

8 min de leitura · Intermediário · Revisado em

Uma fila, uma coisa por vez

O JavaScript da página roda em uma única thread: executa um trecho de código por vez, até o fim. Mesmo assim, ele espera requisições, timers e cliques sem travar. Quem faz isso funcionar é o event loop.

Operações demoradas, como fetch ou setTimeout, são entregues ao navegador. Quando terminam, a função de retorno (callback) entra em uma fila. O event loop só pega o próximo item da fila quando a pilha de chamadas está vazia.

Pilha de chamadas
As funções em execução agora. Uma função entra quando é chamada e sai quando retorna.
APIs do ambiente
Timers, rede e eventos do DOM. Ficam fora do JavaScript, no navegador ou no Node.js.
Fila de tarefas
Callbacks de setTimeout, setInterval, eventos de clique e mensagens.
Fila de microtarefas
Continuações de Promises (then, catch, await) e queueMicrotask. Têm prioridade.

A regra de ouro

  1. Execute o código atual até o fim

    Nada interrompe uma função no meio.

  2. Esvazie a fila de microtarefas inteira

    Incluindo microtarefas criadas durante esse processo.

  3. Deixe o navegador atualizar a tela, se precisar

    Estilos, layout e pintura acontecem entre tarefas.

  4. Pegue a próxima tarefa da fila e recomece

    Uma tarefa por volta do loop.

Preveja a ordem

Antes de ler a saída, tente adivinhar a ordem dos logs.

console.log('1: início');

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

Promise.resolve().then(() => console.log('3: promise'));

queueMicrotask(() => console.log('4: microtarefa'));

console.log('5: fim');
1: início
5: fim
3: promise
4: microtarefa
2: timeout
  • 1 e 5 são código síncrono: rodam primeiro, na ordem.
  • 3 e 4 são microtarefas: rodam assim que a pilha esvazia, na ordem em que foram agendadas.
  • 2 é uma tarefa: mesmo com 0 ms, espera todas as microtarefas.

O mesmo vale para async/await

async function carregar() {
  console.log('A');
  await null;
  console.log('B'); // vira uma microtarefa
}

console.log('1');
carregar();
console.log('2');
1
A
2
B

O que isso muda no seu código

Trava a tela

Loops longos

Enquanto um cálculo pesado roda, a página não responde a cliques nem se redesenha.

  • Divida o trabalho em partes menores
  • Use um Web Worker para cálculos pesados

Não é imediato

setTimeout(fn, 0)

Significa "o quanto antes, depois do código atual e das microtarefas". Depois de alguns timers aninhados, o navegador impõe um atraso mínimo de 4 ms.

Pode congelar

Microtarefas infinitas

Uma Promise que agenda outra para sempre impede o navegador de chegar à etapa de desenhar a tela.

Ordem garantida

Dentro de uma função

Nenhum callback roda no meio do seu código síncrono. Outra parte do programa só executa quando a função termina ou chega a um await.

Referências

Trilhas relacionadas