Por que não é possível realizar operações de cálculo prolongadas em um método assíncrono?

Operações de cálculo prolongadas em um método assíncrono executado no isolado principal (thread de UI) bloqueiam a UI. Apesar de o método assíncrono usar Future ou async/await, ele ainda é executado na mesma thread. Enquanto uma tarefa que consome muitos recursos está em andamento, a UI não pode ser atualizada, o que leva ao congelamento da aplicação.

Para realizar operações longas sem bloquear a UI, deve-se usar:

• Isolados: Fios de execução separados que não compartilham memória com o isolado principal. A comunicação entre isolados é feita através de ports (SendPort, ReceivePort).
• Função Compute: Uma wrapper conveniente para criar e gerenciar isolados para cálculos pequenos.

import 'dart:isolate';
import 'package:flutter/foundation.dart';

// Função que realiza cálculos longos
int performHeavyComputation(int data) {
  // Simulação de cálculos longos
  int result = 0;
  for (int i = 0; i < 1000000000; i++) {
    result += i;
  }
  return result + data;
}

// Uso de compute para executar em outro isolado
Future<int> heavyComputationInIsolate(int data) async {
  return compute(performHeavyComputation, data);
}

// Exemplo de uso em StatefulWidget
class MyWidgetState extends State<MyWidget> {
  int computationResult = 0;

  Future<void> _startComputation() async {
    // Chamada de cálculos longos em outro isolado
    computationResult = await heavyComputationInIsolate(10);
    setState(() {
      // Atualização da UI após obter o resultado
    });
  }

  @override
  Widget build(BuildContext context) {
    return Center(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: <Widget>[
          Text('Resultado dos cálculos: $computationResult'),
          ElevatedButton(
            onPressed: _startComputation,
            child: const Text('Iniciar cálculos'),
          ),
        ],
      ),
    );
  }
}