---
title: "A ordem das filas e um laço ocupado"
url: "https://www.mikefluff.com/pt/experiments/js-ch09-event-loop"
locale: "pt"
author: "Mikhail Savchenko (Mike Fluff)"
updated: "2026-11-18"
description: "O event loop do JavaScript, microtarefas e timers"
book: "https://www.mikefluff.com/pt/books/from-closures-to-autonomous-systems"
alternates:
  - locale: "en"
    url: "https://www.mikefluff.com/en/experiments/js-ch09-event-loop"
    markdown: "https://www.mikefluff.com/en/experiments/js-ch09-event-loop.md"
  - locale: "ru"
    url: "https://www.mikefluff.com/ru/experiments/js-ch09-event-loop"
    markdown: "https://www.mikefluff.com/ru/experiments/js-ch09-event-loop.md"
  - locale: "pt"
    url: "https://www.mikefluff.com/pt/experiments/js-ch09-event-loop"
    markdown: "https://www.mikefluff.com/pt/experiments/js-ch09-event-loop.md"
  - locale: "es"
    url: "https://www.mikefluff.com/es/experiments/js-ch09-event-loop"
    markdown: "https://www.mikefluff.com/es/experiments/js-ch09-event-loop.md"
---

# A ordem das filas e um laço ocupado

*O event loop do JavaScript, microtarefas e timers*

## O que é o event loop do JavaScript?

O event loop é a forma como um runtime JavaScript de uma só thread decide o que roda em seguida. O código que está rodando nunca é interrompido. Quando ele termina, o runtime esvazia até o fim a fila de microtarefas, onde ficam as continuações de promessas e os callbacks de queueMicrotask. Só então o laço pega a próxima tarefa: um timer, uma mensagem que chegou, uma leitura concluída e, no navegador, também a renderização de um quadro. Um callback longo demais, ou uma fila de microtarefas que se realimenta, segura todos os timers e todos os outros callbacks até acabar.

O JavaScript tem uma única thread, e quem decide quando cada pedaço de código a recebe é o runtime. Há várias formas de pôr trabalho na fila, e as filas são esvaziadas numa ordem fixa: primeiro o código síncrono até o fim, depois todas as microtarefas, inclusive as continuações de promessas, e só então a próxima tarefa vinda de timers, mensagens, entrada e saída. A ordem dentro desse último grupo fica em parte a critério da implementação.

Na primeira aba, ponha seis linhas na ordem que você espera e rode o código de verdade: um setTimeout com atraso zero, requestAnimationFrame, uma mensagem por MessageChannel, promise.then, queueMicrotask e um registro síncrono. Vinte execuções seguidas mostram que parte da ordem se mantém sempre e qual pode mudar. A segunda aba roda no seu navegador o block.js do livro: um timer de 10 ms mede por dois segundos o atraso de cada tick com o laço livre, ocupado 50 ms a cada 100 ms com cálculo, ou inundado por uma cadeia de promessas durante um segundo. No último modo a página congela durante esse segundo.

No livro, no Node 24, a ordem foi: código síncrono, process.nextTick, promise.then, queueMicrotask, setTimeout 0, setImmediate, depois o callback de readFile, dentro do qual setImmediate veio antes de setTimeout 0. No módulo principal o timer passou à frente de setImmediate 40 vezes em 40, e mesmo assim a documentação do Node diz que essa ordem é indefinida. O atraso mediano do timer foi de 1,0 ms em todos os modos; o percentil 99 foi 1,1 ms com o laço livre, 49,3 ms com o cálculo e 990,1 ms com a cadeia de promessas, que deu cerca de 30 milhões de voltas naquele segundo.

O capítulo fala da obrigação que o runtime deixou para o programador. O agendamento ficou com o event loop, e em troca, enquanto o seu código roda, nenhum outro mexe nos seus dados, e travas não são necessárias. Sobrou uma regra rígida, não ocupar o laço, e dá para quebrá-la sem nenhuma função longa, com uma cadeia infinita de promessas instantâneas. Ninguém verifica isso: o servidor simplesmente passa a responder mais devagar a todos os outros.

_A página tem um experimento interativo que roda no navegador: https://www.mikefluff.com/pt/experiments/js-ch09-event-loop_

## Fontes

- [Node.js, The Node.js event loop, timers and process.nextTick()](https://nodejs.org/en/learn/asynchronous-work/event-loop-timers-and-nexttick)
- [HTML Standard, Event loops](https://html.spec.whatwg.org/multipage/webappapis.html#event-loops)
- [MDN, Using microtasks in JavaScript with queueMicrotask()](https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide)

## Do livro

Ao lado dele no livro:

> A documentação do Node não esconde isso. No módulo principal, diz ela, a ordem entre um timer de atraso zero e setImmediate é indefinida e depende de quão rápido o processo está rodando naquele momento, e dentro do tratamento de entrada e saída setImmediate vem sempre primeiro. Na minha máquina, o timer no módulo principal passou à frente de setImmediate em todas as quarenta execuções de quarenta, e essa é uma estatística perigosa. O programador que verificou a ordem quarenta vezes na sua máquina e construiu a lógica em cima dela um dia vai descobrir que num servidor carregado a ordem é outra. Só dá para confiar na ordem que está escrita na documentação. O que aconteceu na sua máquina não garante nada.

- Ler o capítulo: [Capítulo 9. O event loop](https://www.mikefluff.com/pt/read/from-closures-to-autonomous-systems/ch09) (início livre, o resto no livro completo; Markdown: https://www.mikefluff.com/pt/read/from-closures-to-autonomous-systems/ch09.md)

- Livro: [JavaScript: das closures aos sistemas autônomos](https://www.mikefluff.com/pt/books/from-closures-to-autonomous-systems)
