Comprendre les isolats de flottement – un guide de la concurrence et du parallélisme dans Flutter

Introduction

Dans le développement d’applications mobiles modernes, les performances sont cruciales. Flutter, la boîte à outils de l’interface utilisateur de Google pour la création d’applications compilées nativement, fournit un moyen de créer des applications hautement performantes. L’un des principaux aspects de la performance dans n’importe quelle application est de gérer la concurrence et le parallélisme. C’est là que les isolats de flottement entrent.

Dans cet article, nous allons plonger en profondeur dans les isolats de flottement, expliquant ce qu’ils sont, pourquoi ils sont utiles et comment les utiliser dans vos applications Flutter.

Isolats Image gracieuseté par (https://docs.flutter.dev/perf/isolates)

Que sont les isolats de flottement?

Dans Flutter, un isolat est un fil d’exécution séparé. Il vous permet d’exécuter le code simultanément, ce qui signifie que vous pouvez effectuer des tâches en parallèle sans bloquer le thread principal (thread d’interface utilisateur). Ceci est particulièrement utile pour exécuter des opérations à forte intensité de processeur ou à long terme qui pourraient autrement geler ou ralentir l’interface utilisateur.

Cependant, contrairement aux fils traditionnels dans d’autres langages de programmation, les isolats en flottement ne partagent pas de mémoire entre eux. Chaque isolat a son propre tas de mémoire, et ils communiquent entre eux via le passage du message.

Caractéristiques clés des isolats de flottement:

• Pas de mémoire partagée: chaque isolat a son propre espace mémoire indépendant, ce qui aide à éviter les conditions de course et les problèmes qui surviennent souvent dans des environnements multithreading.
• Passage des messages: La communication entre les isolats se produit en envoyant des messages (données), ce qui garantit que les isolats restent découplés et n’interfèrent pas directement avec la mémoire de l’autre.
• Concurrence, pas parallélisme: Bien que les isolats fonctionnent simultanément, ils ne s’exécutent pas nécessairement en parallèle à moins que vous ayez plusieurs processeurs ou cœurs disponibles sur l’appareil. Sur les dispositifs uniques, les isolats peuvent sembler s’exécuter séquentiellement mais assurent toujours de la concurrence.

Pourquoi utiliser des isolats de flottement?

Flutter utilise une boucle d’événement unique pour exécuter le code d’interface utilisateur. Bien que cela soit efficace dans de nombreux cas, certaines tâches – telles que des calculs complexes, du traitement des données ou des opérations d’E / S à long terme – peuvent bloquer le thread d’interface utilisateur et faire en sorte que l’application ne réponde pas. Les isolats de flottement peuvent aider à résoudre ce problème.

Quand utiliser des isolats:

• Computations lourdes: si vous effectuez des calculs à forte intensité de ressources (par exemple, le traitement d’image, le chiffrement, etc.), l’utilisation d’isolats garantit que ces opérations n’interfèrent pas avec le thread d’interface utilisateur.
• Requêtes de réseau ou de base de données: effectuer de longues opérations d’E / S, telles que l’interrogation d’une API distante ou la lecture d’une grande base de données, dans un isolat empêche l’interface utilisateur de congélation.
• Multitâche: lorsque votre application nécessite des tâches simultanées (comme la gestion de plusieurs tâches d’arrière-plan), les isolats vous permettent de les gérer simultanément sans bloquer l’interface utilisateur.

Comment utiliser les isolats de flottement

Maintenant que nous savons ce que sont les isolats et pourquoi ils sont utiles, regardons comment les mettre en œuvre dans Flutter.

Étape 1: Importer des packages requis

Tout d’abord, vous devrez importer le DART: Async et Dart: Isoler les bibliothèques. Ces bibliothèques fournissent les classes et fonctions nécessaires pour créer et gérer des isolats.

import 'dart:isolate'; 
import 'dart:async';

Étape 2: Créez la fonction isolat

La fonction que vous souhaitez exécuter dans un isolat ne doit pas référencer directement les variables externes du thread principal. Au lieu de cela, il devrait recevoir toutes ses données via le passage du message.

void isolateFunction(SendPort sendPort) {
  // Perform heavy computation here
  int result = 0;
  for (int i = 0; i < 10000000; i++) {
    result += i;
  }

  // Send the result back to the main isolate
  sendPort.send(result);
}

Étape 3: engendrant un isolat

Ensuite, engendrer un nouvel isolat et y transmettre des données. Vous devrez utiliser un Receseport pour communiquer avec l’isolat principal.

void startIsolate() async {
  // Create a ReceivePort to receive messages from the isolate
  final receivePort = ReceivePort();

  // Spawn the isolate and pass the SendPort of the ReceivePort
  await Isolate.spawn(isolateFunction, receivePort.sendPort);

  // Listen for messages from the isolate
  receivePort.listen((message) {
  print('Result from isolate: $message');
  });
}

Étape 4: Exécutez l’isolat

Enfin, vous pouvez appeler startisolate () dans votre application Flutter pour exécuter l’isolat.

void main() {
startIsolate();
}

Exemple de cas d’utilisation: effectuer un calcul lourd

Voici un exemple complet de la façon dont vous pourriez utiliser des isolats pour effectuer un calcul long en arrière-plan:

import 'dart:async';
import 'dart:isolate';

void isolateFunction(SendPort sendPort) {
  // Simulate heavy computation
  int result = 0;
  for (int i = 0; i < 100000000; i++) {
    result += i;
  }

  // Send result back to main isolate
  sendPort.send(result);
  }

void startIsolate() async {
  final receivePort = ReceivePort();

// Spawn a new isolate
await Isolate.spawn(isolateFunction, receivePort.sendPort);

// Listen to the result from the isolate
receivePort.listen((message) {
  print('Computation result from isolate: $message');
 });
}

void main() {
  startIsolate();
}

Étape 5: Gestion des erreurs d’isolat

Comme toute autre opération asynchrone, les isolats peuvent rencontrer des erreurs. Vous pouvez gérer ces erreurs en écoutant le RereaPort pour les messages d’erreur et en effectuant une gestion des erreurs dans l’isolat.

void isolateFunction(SendPort sendPort) {
  try {
  // Simulate an error
  throw Exception('Something went wrong!');
  } catch (e) {
    sendPort.send('Error: $e');
  }
}

Meilleures pratiques pour travailler avec des isolats

• Évitez les données partagées: Les isolats ne partagent pas la mémoire, vous devez donc transmettre des données entre les isolats à l’aide du passage du message. Évitez d’essayer de partager l’état entre les isolats directement.
• Utilisez des isolats pour les tâches liées au processeur: Utilisez des isolats pour les opérations qui impliquent un calcul de CPU lourd (par exemple, le traitement des données, le cryptage). Pour les tâches qui impliquent des E / S lourdes (par exemple, les demandes de réseau), envisagez d’utiliser des opérations et des futures asynchrones à la place.
• Minimiser la communication entre les isolats: Étant donné que le passage du message peut entraîner des frais généraux, essayez de minimiser la fréquence de communication entre les isolats. Le regroupement des tâches connexes ensemble peut aider à réduire le besoin d’échanges de messages constants.
• Ports fermés: Fermez toujours Sendport et ReceaPort lorsque vous avez terminé les utiliser pour éviter les fuites de mémoire et assurez-vous que les ressources sont libérées correctement.

Limites des isolats

Bien que les isolats soient puissants, il y a certaines limites que vous devez connaître:

• Aucun état partagé: Les isolats ne peuvent pas partager la mémoire, ce qui rend plus difficile de partager des données mutables entre eux. Vous devez utiliser le passage du message pour envoyer des données d’avant en arrière.
• Performance Overhead: La création et la gestion des isolats entraînent des frais généraux de performance, en particulier lors de la communication entre les isolats. Pour les tâches qui ne nécessitent pas de véritable parallélisme, envisagez d’utiliser d’autres techniques de concurrence comme Future ou Stream.
• Pas d’accès direct à l’interface utilisateur: Étant donné que les isolats fonctionnent sur des threads séparés, ils ne peuvent pas modifier directement l’interface utilisateur. Toutes les mises à jour d’interface utilisateur doivent se produire sur l’isolat principal (thread d’interface utilisateur) en renvoyant des messages au thread principal.

Conclusion

Les isolats de flottement sont un outil puissant pour améliorer les performances et la réactivité de vos applications de flottement. En exécutant des tâches à forte intensité de processeur ou des opérations de longue durée dans des isolats séparés, vous pouvez garder le fil d’interface utilisateur principal libre pour gérer les interactions utilisateur sans décalage ni bégaiement.

En comprenant le fonctionnement des isolats et quand les utiliser, vous pouvez faire passer vos applications Flutter au niveau supérieur en termes de performances et de réactivité. Si vous avez besoin d’exécuter des tâches parallèles ou de gérer les processus d’arrière-plan, les isolats sont la solution parfaite.

Alors, allez-y, commencez à explorer des isolats dans Flutter et créez des applications plus lisses et plus réactives qui offrent une meilleure expérience à vos utilisateurs!

Vous avez trouvé cela utile? PARTAGEZ-LE