Event Loops: Entendendo as Futures no Dart
Tags: dart, future, futures, eventloop
Published: 2024-04-24 12:34:37

No dia a dia quando estamos desenvolvendo uma aplicação Flutter nos deparamos com situações que precisamos executar processos que levam um certo tempo e não queremos que trave o processo principal, como um dado de uma API por exemplo, uma tecnica que podemos utilizar é a de programação assíncrona que no Flutter é através das Futures.

Para utilizarmos as Futures existem 3 palavras reservadas: **async, await e Future**.

> · **await** — esta palavra determina que a linha de execução irá esperar a execução de um outro método **future** (no caso a linha 2) antes de prosseguir a execução da função, aguardando que a future seja resolvida, isto é muito utilizado se o restante da função depende do retorno da **Future** que irá ser executada.

> **Lembrando que pode ser que a resolução da Future nem sempre é o estado esperado.**

> · **async **— serve para determinar que é assíncrono, geralmente é utilizado caso  o método tenha uma chamada **await.**

> · **Future** — determina que uma função irá retornar algo no “futuro”, ou seja, é uma função que levará um tempo até ser finalizada.

![](https://cdn-images-1.medium.com/max/800/1*DSL7fB6U5p7Igh5wvTL4gg.png)

Basicamente quando se executa a Future pode estar em três estados.

> · Ela pode estar uncompleted (incompleta), ou seja, ela ainda está em execução.

> · Ela pode estar completa com valor

> · Ela pose estar completa com erro

É possível e recomendável tratar esses estados em minha aplicação.  
Vale destacar que Futures são apenas uma forma de simplificar as operações de Event Loops e cabe ressaltar que o código Dart é executado em apenas um thread (ou Isolate). Portanto, é importante lembrar que :

> **“EVENT LOOPS E FUTURES NÃO SÃO PROGRAMAÇAO PARALELA.”**

**Entao não se esqueçam: EVENT LOOPS E FUTURES NÃO SÃO PROGRAMAÇAO PARALELA.**

Outra forma de lidar com as Futures é utilizando as funções **then()** e **onError()**. Elas permitem tratar os resultados e erros de forma mais organizada e simplificada.

![](https://cdn-images-1.medium.com/max/800/1*WsoZrPi19g9zs80N97Tfbg.png)

### Event Loops

![](https://cdn-images-1.medium.com/max/800/1*_l3ac8SnMRFsKOt_wCXrPQ.gif)

No Dart ele possui um Fila de Eventos onde toda vez que uma Future é executada ele insere esse evento dentro do Event Queue para ser executado.

![](https://cdn-images-1.medium.com/max/800/1*BG9JEBwMzFpUKKC6zEcIvw.png)

O Event Queue tem as seguintes características

> · Ele é FIFO (First In First Out), ou seja, o primeiro evento que entra na fila é o primeiro a ser executado.
> · Geralmente é utilizado quando há a necessidade de algum retorno.
> · Possui baixa prioridade

Também temos um outro tipo de fila que são as filas de MicroTasks, que possuem as seguintes características

> · Ele é FIFO (First In First Out), ou seja, o primeiro evento que entra na fila é o primeiro a ser executado.
> · Geralmente é utilizado quando NÃO há a necessidade de algum retorno, funções simples.
> · Possui alta prioridade

Então se eu tiver no meu Event loop a inserção de vários eventos e microtasks de forma desordenada ele será re-priorizado antes no início da execução da fila de forma que as microtasks sejam executados primeiro.

![](https://cdn-images-1.medium.com/max/800/1*J4BzPAPBBhdZ-PQpEPSIgQ.png)

Nesse caso irá executar primeiro o MicroTaskA depois a MicroTaskB depois o EventA e finalmente o EventC.

![](https://cdn-images-1.medium.com/max/800/1*EzlGynKckXX9WRVNTIVfXA.png)

O fluxo ficaria da seguinte forma

![](https://cdn-images-1.medium.com/max/800/1*G3S02QvoFJLTYnlbjEqAVw.png)

Então vamos analisar o código abaixo

{% gist https://gist.github.com/toshiossada/3c12610d1f84ab3e88ff4590d6ca9f5c file=main.dart %}

Teremos o seguinte resultado, onde a **main()** será executada primeiro, após isso será executadas as **microtasks** e por fim os Future, deixando por último o que tem o **dalay**. Tudo seguinto o principio do First In First Out em cada fila.

![](https://cdn-images-1.medium.com/max/800/1*3ju7bE36p6ihKKeLORronQ.gif)

Agora vamos olhar para outro exemplo mais complexo e analisar a saída.

{% gist https://gist.github.com/toshiossada/ab7fc368536e38d62a5496ec9a53d034 file=main.dart %}

![](https://cdn-images-1.medium.com/max/800/1*sY2rD7ANKCpDevAaE_qpCA.gif)

Note que quando temos o **await** nas chamadas das Futures o método é executado imediatamente e não é inserido no **eventloop** para processamento posterior

Sabia desse funcionamento das Futures? E lembrando que isso NÃO é paralelismo, para isto precisaremos trabalho com outro conceito que são as Isolates que trataremos em um próximo artigo.

Alguns vídeos interessantes sobre o assunto:
<a href="https://www.youtube.com/watch?v=OTS-ap9_aXc" target="_blank">
 <img src="https://img.youtube.com/vi/OTS-ap9_aXc/0.jpg" alt="Monorepo (Por Que Essa Estratégia Funciona em Grandes Empresas?) " width="240" height="180" border="10" />
</a>
<a href="https://www.youtube.com/watch?v=vl_AaCgudcY" target="_blank">
 <img src="https://img.youtube.com/vi/vl_AaCgudcY/0.jpg" alt="Monorepo (Por Que Essa Estratégia Funciona em Grandes Empresas?) " width="240" height="180" border="10" />
</a>
<a href="https://www.youtube.com/watch?v=5rjQ5ooWDoY" target="_blank">
 <img src="https://img.youtube.com/vi/5rjQ5ooWDoY/0.jpg" alt="Monorepo (Por Que Essa Estratégia Funciona em Grandes Empresas?) " width="240" height="180" border="10" />
</a>

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/obcg0d2y00yddve9quky.png)


Entre em nosso discord para interagir com a comunidade: https://discord.com/invite/flutterbrasil
https://linktr.ee/flutterbrasil