Qual é o seu conhecimento sobre assíncrono em Dart…

A asincronia em Dart é implementada usando:

Conceito de "isolados" (Isolates): Processos de trabalho independentes, cada um com sua própria memória. São usados para executar tarefas intensivas em recursos em paralelo sem bloquear o thread principal da interface de usuário. A comunicação entre isolados ocorre através de ports (ReceivePort, SendPort).
Palavras-chave async, await:
- async marca uma função que realizará operações assíncronas e retornará um Future.
- await é usado dentro de uma função async para esperar a conclusão de um Future. Quando alcançado, a execução da função é suspensa, permitindo que outras operações sejam executadas enquanto o Future termina com um valor ou erro.
```
Future<String> fetchData() async {
  // Simulação de atraso
  await Future.delayed(Duration(seconds: 2));
  return 'Dados recebidos';
}

void main() async {
  print('Início');
  String result = await fetchData(); // Espera a conclusão do fetchData
  print(result);
  print('Fim');
}
```
Classe Future<T>: Representa o resultado de uma operação assíncrona que estará disponível no futuro. Future pode estar em um de três estados:
- Não concluído (uncompleted)
- Concluído com valor (completed with a value)
- Concluído com erro (completed with an error)
O tratamento da conclusão do Future é feito com then(), catchError(), whenComplete() ou await.

Classe Stream<T>: Representa uma sequência de eventos assíncronos. É usada para processar fluxos de dados, por exemplo, leitura de arquivo, recebimento de dados via rede, eventos de interface de usuário. O fluxo pode ser de assinatura única (single-subscription) ou de múltiplas assinaturas (broadcast). O processamento de eventos do fluxo é feito com listen(), async*, yield.

Stream<int> countStream(int to) async* {
  for (int i = 1; i <= to; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i; // Enviando valor ao fluxo
  }
}

void main() {
  Stream<int> stream = countStream(3);
  stream.listen(
    (data) => print('Recebido: $data'),
    onError: (error) => print('Erro: $error'),
    onDone: () => print('Fluxo concluído'),
  );
}

A asincronia em Dart é baseada no modelo de "loop de eventos" (event loop). O thread principal executa o código sequencialmente, mas ao encontrar uma operação assíncrona (por exemplo, await ou Future.then), ela é delegada ao "pool de eventos" (event queue) e o código continua a ser executado. Quando a operação assíncrona termina, seu resultado é enviado de volta ao "pool de eventos". O ciclo de eventos verifica continuamente o "pool de eventos" e executa tarefas quando o thread principal está livre.

Qual é o seu conhecimento sobre assíncrono em Dart?