JavaScript Academy · Aula

Macrotarefas e a fila de tarefas

Entenda como temporizadores e E/S são agendados.

Macrotarefas e a fila de tarefas é uma aula grátis de JavaScript Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de JavaScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de JavaScript Academy inclui 4 aulas no total.

O que é uma macrotarefa?

Uma macrotarefa (também chamada de tarefa) é uma unidade de trabalho programada para ser executada mais tarde, depois que o código síncrono atual terminar. As funções de retorno de setTimeout são o exemplo clássico.

Macrotarefas aguardam na fila de tarefas até que a pilha de chamadas esteja vazia.

setTimeout adia o trabalho

setTimeout registra uma função de retorno para ser executada mais tarde. Mesmo com um atraso de 0, ela é executada depois de todo o código síncrono atual.

console.log('first');
setTimeout(() => console.log('third (timeout)'), 0);
console.log('second');

A fila de tarefas

Quando um temporizador é acionado, sua função de retorno é colocada na fila de tarefas. O loop de eventos retira uma tarefa dessa fila somente quando a pilha de chamadas está vazia, executa-a até o fim e verifica novamente.

console.log('sync start');
setTimeout(() => console.log('task 1'), 0);
setTimeout(() => console.log('task 2'), 0);
console.log('sync end');

As tarefas são executadas na ordem em que entram na fila

Tarefas com o mesmo atraso são executadas na ordem em que foram programadas. A fila de tarefas é FIFO: a primeira a entrar é a primeira a sair.

setTimeout(() => console.log('A'), 0);
setTimeout(() => console.log('B'), 0);
setTimeout(() => console.log('C'), 0);
console.log('sync');

O atraso é mínimo, não exato

O atraso informado é o tempo mínimo antes que a função de retorno possa ser executada. A execução real só acontece depois que a pilha é esvaziada e as tarefas anteriores terminam, portanto pode ocorrer mais tarde.

setTimeout(() => console.log('100ms'), 100);
setTimeout(() => console.log('0ms'), 0);
console.log('synchronous runs first');

Ordenação pelo atraso

Atrasos diferentes alteram a ordem: atrasos menores tornam-se elegíveis mais cedo e, em geral, são executados antes dos maiores, independentemente da ordem de programação.

setTimeout(() => console.log('50'), 50);
setTimeout(() => console.log('10'), 10);
setTimeout(() => console.log('30'), 30);
console.log('start');

Uma tarefa por turno do loop

O loop de eventos executa exatamente uma macrotarefa por turno e, depois, realiza outro trabalho antes da próxima. Isso mantém o sistema responsivo entre as tarefas.

console.log('1');
setTimeout(() => {
  console.log('2');
  setTimeout(() => console.log('4'), 0);
}, 0);
setTimeout(() => console.log('3'), 0);

Temporizadores aninhados entram na fila depois

Um temporizador programado dentro de uma tarefa entra na fila atrás das tarefas que já estão aguardando, portanto é executado em um turno posterior do loop.

setTimeout(() => {
  console.log('outer');
  setTimeout(() => console.log('inner nested'), 0);
}, 0);
setTimeout(() => console.log('sibling'), 0);

setInterval também cria macrotarefas

setInterval agenda uma macrotarefa repetitiva. Aqui, executamos algumas iterações e paramos com clearInterval para manter a saída limitada.

let count = 0;
const id = setInterval(() => {
  count++;
  console.log('tick ' + count);
  if (count === 3) clearInterval(id);
}, 10);
console.log('interval scheduled');

O síncrono sempre vence

Por menor que seja o atraso, toda macrotarefa espera atrás de todo o código síncrono da execução atual. A pilha precisa ficar vazia primeiro.

setTimeout(() => console.log('macrotask'), 0);
for (let i = 1; i <= 3; i++) console.log('sync ' + i);
console.log('done sync');

Por que as macrotarefas são importantes

Macrotarefas permitem adiar trabalho sem bloquear. Dividir um trabalho pesado em partes temporizadas mantém o aplicativo responsivo. Mas macrotarefas não têm a maior prioridade: microtarefas (Promises) são executadas antes da próxima macrotarefa, como você verá a seguir.

console.log('schedule');
setTimeout(() => console.log('runs after sync'), 0);
console.log('still sync');

Verificação rápida

Quando a função de retorno de setTimeout(cb, 0) é executada?

Recapitulação: macrotarefas

Você aprendeu como o trabalho adiado é programado:

Macrotarefas (setTimeout, setInterval) aguardam na fila de tarefas.
A fila é FIFO; o loop de eventos executa uma tarefa por turno.
O atraso é mínimo, e o código síncrono sempre é executado primeiro.
Microtarefas têm prioridade maior, assunto que você explorará a seguir.

Perguntas Frequentes

A aula “Macrotarefas e a fila de tarefas” é grátis?

Sim — o texto completo de “Macrotarefas e a fila de tarefas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de JavaScript Academy, atualize para CoddyKit PRO. O curso de JavaScript Academy inclui 4 aulas no total.

O que vou aprender em “Macrotarefas e a fila de tarefas”?

Entenda como temporizadores e E/S são agendados. Você pratica JavaScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar JavaScript Academy?

Nenhuma experiência prévia é necessária. JavaScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Macrotarefas e a fila de tarefas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de JavaScript Academy?

Sim. Cada aula de JavaScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para JavaScript Academy