El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este tema, exploraremos cómo manejar la concurrencia en Flutter utilizando isolates. La concurrencia es crucial para mantener la UI de tu aplicación fluida y receptiva, especialmente cuando se realizan operaciones intensivas en recursos como el procesamiento de datos o la comunicación en red.

¿Qué es un Isolate?

Un isolate es una unidad de ejecución independiente en Dart. A diferencia de los hilos (threads) en otros lenguajes de programación, los isolates no comparten memoria. Cada isolate tiene su propio espacio de memoria y comunicación con otros isolates a través de mensajes.

Características de los Isolates:

Independencia: Cada isolate tiene su propio heap de memoria.
Comunicación por Mensajes: Los isolates se comunican mediante el paso de mensajes.
No hay Compartición de Estado: No hay variables compartidas entre isolates, lo que evita problemas de sincronización.

¿Por qué Usar Isolates?

En Flutter, la UI se ejecuta en el hilo principal. Si realizas operaciones intensivas en el hilo principal, la UI puede volverse lenta o no responder. Usar isolates permite mover estas operaciones a un hilo separado, manteniendo la UI fluida.

Creando y Usando Isolates

Ejemplo Básico

Vamos a crear un ejemplo básico donde un isolate realiza una operación intensiva (como calcular números primos) y envía el resultado de vuelta al hilo principal.

import 'dart:isolate';

// Función que se ejecutará en el isolate
void calculatePrimes(SendPort sendPort) {
  int n = 100000;
  List<int> primes = [];
  for (int i = 2; i <= n; i++) {
    bool isPrime = true;
    for (int j = 2; j <= i ~/ 2; j++) {
      if (i % j == 0) {
        isPrime = false;
        break;
      }
    }
    if (isPrime) {
      primes.add(i);
    }
  }
  sendPort.send(primes);
}

void main() async {
  // Recibir el puerto de mensajes del isolate
  ReceivePort receivePort = ReceivePort();

  // Crear el isolate
  await Isolate.spawn(calculatePrimes, receivePort.sendPort);

  // Escuchar los mensajes del isolate
  receivePort.listen((message) {
    print('Primos calculados: $message');
    receivePort.close();
  });
}

Explicación del Código

Importar dart:isolate: Necesario para trabajar con isolates.
Función calculatePrimes: Esta función se ejecutará en el isolate. Calcula números primos y envía el resultado de vuelta al hilo principal usando un SendPort.
Crear un ReceivePort: Este puerto recibe mensajes del isolate.
Crear el Isolate: Usamos Isolate.spawn para crear un nuevo isolate y ejecutar calculatePrimes.
Escuchar Mensajes: El ReceivePort escucha los mensajes enviados desde el isolate y los procesa.

Ejercicio Práctico

Ejercicio

Crea una aplicación Flutter que tenga un botón para iniciar una operación intensiva (como calcular la suma de una gran lista de números). Usa un isolate para realizar esta operación y muestra el resultado en la UI.

Solución

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

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('Isolates y Concurrencia'),
        ),
        body: Center(
          child: IsolateExample(),
        ),
      ),
    );
  }
}

class IsolateExample extends StatefulWidget {
  @override
  _IsolateExampleState createState() => _IsolateExampleState();
}

class _IsolateExampleState extends State<IsolateExample> {
  String _result = 'Presiona el botón para iniciar';

  void _startCalculation() async {
    ReceivePort receivePort = ReceivePort();
    await Isolate.spawn(_calculateSum, receivePort.sendPort);

    receivePort.listen((message) {
      setState(() {
        _result = 'Resultado: $message';
      });
      receivePort.close();
    });
  }

  static void _calculateSum(SendPort sendPort) {
    int sum = 0;
    for (int i = 0; i < 100000000; i++) {
      sum += i;
    }
    sendPort.send(sum);
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
        Text(_result),
        SizedBox(height: 20),
        ElevatedButton(
          onPressed: _startCalculation,
          child: Text('Iniciar Cálculo'),
        ),
      ],
    );
  }
}

Explicación del Código

Interfaz de Usuario: La UI tiene un botón y un texto para mostrar el resultado.
Método _startCalculation: Crea un ReceivePort, inicia el isolate y escucha los mensajes.
Método _calculateSum: Realiza la operación intensiva (suma de números) y envía el resultado de vuelta al hilo principal.

Conclusión

En esta sección, aprendimos sobre los isolates y cómo usarlos para manejar la concurrencia en Flutter. Los isolates son una herramienta poderosa para mantener la UI de tu aplicación fluida y receptiva al mover operaciones intensivas fuera del hilo principal. Practica creando y usando isolates en diferentes escenarios para dominar su uso en tus aplicaciones Flutter.

Isolates y Concurrencia

¿Qué es un Isolate?

Características de los Isolates:

¿Por qué Usar Isolates?

Creando y Usando Isolates

Ejemplo Básico

Explicación del Código

Ejercicio Práctico

Ejercicio

Solución

Explicación del Código

Conclusión

Curso de Desarrollo con Flutter

Módulo 1: Introducción a Flutter

Módulo 2: Conceptos Básicos de Programación en Dart

Módulo 3: Widgets en Flutter

Módulo 4: Gestión de Estado

Módulo 5: Navegación y Enrutamiento

Módulo 6: Redes y APIs

Módulo 7: Persistencia y Almacenamiento

Módulo 8: Conceptos Avanzados de Flutter

Módulo 9: Pruebas y Depuración

Módulo 10: Despliegue y Mantenimiento

Módulo 11: Flutter para Web y Escritorio