Event Loop - Parte 2

Olá, pessoal, tudo bem? Como eu disse no último post do Event Loop, parte 1, eu iria trazer algum exemplo para explicar melhor, na prática, o que acontece com o Event Loop. Vamos lá.

• Aqui temos um código que está mexendo diretamente com Futures (em breve terá o conteúdo mais aprofundado sobre Futures e async/await) e com nossas microtasks.
• O código pode parecer confuso, mas vamos destrinchar o que está acontecendo aqui. Primeiro, temos uma conta aritmética padrão que vai imprimir nossa multiplicação. Abaixo do print(c), temos uma scheduleMicrotask. Qual você acha que vai executar primeiro? Se você viu a imagem na primeira parte, pode ver que ele executa primeiro o main(), tudo que é síncrono e depois escuta a fila de microtasks e de eventos. Ou seja, tudo que for síncrono é executado primeiro dentro do event loop, então nossos dois print() serão executados.
• Depois, temos nosso scheduleMicrotask #1 que está solto dentro do main. Ele vai ser executado após nossos print() e depois temos dois Future, um com delay e outro sem delay. O Future sem delay será executado primeiro, e aqui temos algo que é uma "pegadinha". Você pode ver que ele tem um scheduleMicrotask dentro e pode pensar que essa microtask vai ser executada primeiro. Mas não! Por quê? Porque o Future vai passar pela função anônima primeiro, que é o print("future #2"), e depois vai executar o callback dele que está no then(). E aqui, não importa a ordem da scheduleMicrotask, ela sempre vai ser executada por último dentro de um Future, porque o event loop vai vê-la e vai agendá-la e depois que o Future terminar de executar ele dispara a fila de microtask.
• E nosso proximo carinha é oFuture.delayed(), que nesse tempo de explicação ele acabou de terminar. Aqui vai acontecer a mesma coisa com o Future sem delay, ele vai executar o callback e depois agendar a microtask #2, e pronto, ela vai ser executada depois que o Future.delayed finalizar.
• Deixei abaixo a resposta do log e vocês podem ver que tudo que está no future é executado primeiro, e as schedulesMicrotask seram agendadas pelo event loop e executadas depois.

import 'dart:async';

void main() {
const a = 10;
const b = 20;
const c = a * b;

print(c);

scheduleMicrotask(() => print("microtask #1"));

Future.delayed(Duration(seconds: 1), () => {
print("future #1"),
scheduleMicrotask(
() => print("Microtask #2"),
)}).then((_) => print("future #1b"));


Future(() => print("future #2")).then((_) => print("future #2b"))
    .then((_) => scheduleMicrotask(() => print("microtask #3")));

print(a / b);

}

200
0.5
microtask #1
future #2
future #2b
microtask #3
future #1
future #1b
Microtask #2

Por fim, é isso mesmo, galera. Finalizei essa parte dois e provavelmente será a última sobre o Event Loop em si, mas ainda temos vários outros assuntos sobre Dart que eu vou trazer nas próximas semanas.

Texto Feito por Enzo Lanzellotti
Revisado pelo Gemini