Concurrence et Isolate dans Dart

La concurrence est la capacité de gérer plusieurs tâches simultanément.

Le modèle de concurrence de Dart diffère du multithreading traditionnel ; il utilise des Isolates pour effectuer des calculs parallèles.

Ce chapitre présente le modèle de concurrence de Dart, le concept et l'utilisation des Isolates, ainsi que le mécanisme de passage de messages.


Modèle de concurrence de Dart

La plupart des langages de programmation utilisent un modèle multithread à mémoire partagée, où plusieurs threads partagent le même espace mémoire.

L'inconvénient de ce modèle est qu'il est sujet aux conditions de concurrence et aux interblocages.

Dart adopte une stratégie différente :Chaque Isolate possède son propre tas mémoire indépendantLes Isolates ne partagent pas la mémoire.

Ils communiquent par passage de messages, ce qui évite fondamentalement les problèmes de course de données.

Le modèle de concurrence de Dart a trois niveaux :

NiveauMécanismeScénarios applicables
Boucle d'événementsAsynchrone monothread (boucle d'événements)Les opérations d'E/S, les minuteurs et l'interaction utilisateur.
IsolateMémoire isolée + passage de messagesCalcul intensif sur le CPU
Future/StreamSyntaxe de programmation asynchroneLa plupart des scénarios de développement quotidiens

Les besoins de concurrence de la plupart des programmes Dart peuvent être satisfaits avec async/await et Future/Stream. Les Isolates ne sont nécessaires que lorsque vous devez effectuer des calculs lourds intensifs sur le CPU. Introduire des Isolates prématurément rend le code plus complexe pour peu de bénéfices.


Concept et utilisation d'Isolate

Un Isolate est l'unité de concurrence de Dart, et chaque Isolate possède sa propre mémoire indépendante et sa propre boucle d'événements.

Le programme principal s'exécute lui-même dans un Isolate (l'Isolate principal).

Utilisez Isolate.spawn pour créer un nouvel Isolate

Exemple

import 'dart:isolate';

// Cette fonction s'exécutera dans le nouvel Isolate
// SendPort est utilisé pour envoyer des messages à l'Isolate principal
void heavyComputation(SendPort sendPort) {
  print('Le nouvel Isolate commence à calculer...');

  // Simuler un calcul intensif du CPU
  int sum = 0;
  for (int i = 1; i <= 10000000; i++) {
    sum += i;
  }

  // Renvoyer le résultat du calcul à l'Isolate principal
  sendPort.send(sum);

  print('Calcul du nouvel Isolate terminé, résultat envoyé');
}

Future<void> main() async {
  print('Isolate principal démarré');

  // Créer un ReceivePort pour recevoir des messages
  var receivePort = ReceivePort();

  // spawn crée un nouvel Isolate
  await Isolate.spawn(heavyComputation, receivePort.sendPort);

  print('L'Isolate principal peut faire d'autres choses en attendant le résultat...');

  // Attendre le résultat du calcul du nouvel Isolate
  var result = await receivePort.first;
  print('EXEMPLE résultat du calcul : somme de 1 à 10000000 = $result');

  receivePort.close();
  print('Isolate principal terminé');
}
主 Isolate 启动
主 Isolate 在等待结果的同时可以做其他事情...
新 Isolate 开始计算...
新 Isolate 计算完成,结果已发送
EXAMPLE 计算结果: 1 到 10000000 的和 = 50000005000000
主 Isolate 结束

Comparaison : différences de performances avec et sans Isolates.

Exemple

// Exécuter une tâche intensive en CPU dans l'Isolate principal (bloquera)
int fibonacci(int n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

void main() {
  // Calculer dans l'Isolate principal — bloquera toutes les autres opérations
  var startTime = DateTime.now();

  // Remarque : si n est trop grand, ce calcul prendra beaucoup de temps.
  // En développement réel, ce type de calcul devrait être placé dans un Isolate séparé.
  var result = fibonacci(40);

  var elapsed = DateTime.now().difference(startTime);
  print('EXEMPLE Fibonacci(40) = $result');
  print('Temps écoulé : ${elapsed.inMilliseconds}ms');
  print('(Remarque : pendant le calcul, l'Isolate principal ne peut pas traiter d'autres tâches)');
}

Dans les applications Flutter, si un calcul synchrone chronophage est exécuté dans l'Isolate principal, cela provoquera le gel de l'UI. La solution consiste à placer la tâche de calcul dans un Isolate séparé, puis, une fois le calcul terminé, à renvoyer le résultat via des messages et à mettre à jour l'UI.


Mécanisme de passage de messages

Les Isolates communiquent en échangeant des messages via SendPort et ReceivePort.

Les messages doivent être sérialisables (types primitifs, String, List, Map, etc.) ; les fonctions ou fermetures ne peuvent pas être transmises.

Communication bidirectionnelle

Exemple

import 'dart:isolate';

// La fonction de travail qui s'exécute dans le nouvel Isolate
void workerIsolate(SendPort mainSendPort) {
  // Créer son propre ReceivePort pour recevoir les messages de l'Isolate principal
  var workerReceivePort = ReceivePort();

  // Envoyer d'abord le SendPort du worker à l'Isolate principal pour établir un canal bidirectionnel
  mainSendPort.send(workerReceivePort.sendPort);

  print('Isolate de travail : en attente de tâches...');

  // Écouter les tâches envoyées par l'Isolate principal
  workerReceivePort.listen((message) {
    if (message is List<int>) {
      // Tâche reçue : élever au carré chaque nombre de la liste
      print('Isolate de travail : données reçues $message');
      var result = message.map((n) => n * n).toList();

      // Renvoyer le résultat via mainSendPort
      mainSendPort.send(result);
    } else if (message == 'exit') {
      print('Isolate de travail : signal de sortie reçu, arrêt en cours');
      workerReceivePort.close();
      mainSendPort.send('au revoir');
    }
  });
}

Future<void> main() async {
  print('Isolate principal : démarrage');

  // Créer le port de réception principal
  var mainReceivePort = ReceivePort();

  // Démarrer l'isolate Worker
  await Isolate.spawn(workerIsolate, mainReceivePort.sendPort);

  // Attendre que le Worker envoie son SendPort (établir une communication bidirectionnelle)
  SendPort? workerSendPort;
  await for (var msg in mainReceivePort) {
    if (msg is SendPort) {
      workerSendPort = msg;
      print('Isolate principal : communication bidirectionnelle établie avec Worker');
      break;
    }
  }

  // Envoyer la tâche via le SendPort du Worker
  workerSendPort!.send([1, 2, 3, 4, 5]);
  workerSendPort.send([10, 20, 30]);

  // Recevoir le résultat du calcul du Worker
  int responseCount = 0;
  await for (var msg in mainReceivePort) {
    if (msg is List<int>) {
      print('Isolate principal : résultat reçu $msg');
      responseCount++;
      if (responseCount == 2) break;
    }
  }

  // Envoyer le signal de sortie
  workerSendPort.send('exit');
  await for (var msg in mainReceivePort) {
    if (msg == 'goodbye') {
      print('Isolate principal : Worker est sorti');
      break;
    }
  }

  mainReceivePort.close();
  print('EXEMPLE : démo de communication bidirectionnelle terminée');
}
主 Isolate: 启动
主 Isolate: 已建立与 Worker 的双向通信
Worker Isolate: 等待任务...
Worker Isolate: 收到数据 [1, 2, 3, 4, 5]
主 Isolate: 收到结果 [1, 4, 9, 16, 25]
Worker Isolate: 收到数据 [10, 20, 30]
主 Isolate: 收到结果 [100, 400, 900]
Worker Isolate: 收到退出信号,关闭
主 Isolate: Worker 已退出
EXAMPLE 双向通信演示结束

Simplifiez avec Isolate.run (Dart 3.0+)

Dart 3.0 a introduit Isolate.run(), ce qui simplifie grandement l'utilisation de tâches de calcul ponctuelles.

Exemple

import 'dart:isolate';

// Une fonction de calcul chronophage
int complexCalculation(int n) {
  int result = 0;
  for (int i = 0; i < n; i++) {
    result += i * i;
  }
  return result;
}

Future<void> main() async {
  print('Démarrage du calcul...');

  // Isolate.run : une ligne de code, crée automatiquement un Isolate, exécute et renvoie le résultat
  var result = await Isolate.run(() => complexCalculation(10000000));
  print('EXEMPLE : résultat du calcul : $result');

  print('Calcul terminé');

  // Comparaison : si vous n'utilisez pas Isolate
  print('(Si calculé directement dans l'Isolate principal, cela bloquera les autres opérations)');
}
开始计算...
EXAMPLE 计算结果: 333333283333335000000
计算完成
(如果在主 Isolate 中直接计算,会阻塞其他操作)

Isolate.run() convient aux scénarios où vous souhaitez « exécuter un calcul une fois et renvoyer le résultat ». Si vous avez besoin d'une communication continue et bidirectionnelle (comme un service en arrière-plan de longue durée), vous devez utiliser Isolate.spawn() + SendPort/ReceivePort.

Limites du passage de messages d'Isolate.

Peut être transmisNe peut pas être transmis
null, bool, int, double, StringFonctions, fermetures
List, Map, Set (les éléments peuvent aussi être transmis)Stream, Future
SendPort (utilisé pour établir une chaîne de communication).La plupart des objets de types non primitifs
Capacité (jeton d'autorisation)Descripteurs de fichiers, sockets réseau
TransferableTypedData (transfère efficacement de gros blocs de données)Classes personnalisées (sauf si sérialisables)

Comparaison des modèles de concurrence

FonctionnalitésIsolate DartMultithreading traditionnel (par ex., Java)
Modèle de mémoireMémoire indépendante, aucun partageMémoire partagée
Méthode de communicationPassage de messages (SendPort)Variables partagées + verrous
Course aux donnéesN'existe pas (pas de partage)Nécessite une protection par mécanisme de verrouillage
Risque d'interblocageQuasiment inexistantExists
Surcoût de créationRelativement importantRelativement faible
Scénarios applicablesCalcul parallèle intensif en CPUConcurrence générale

Bien que le modèle Isolate de Dart évite les courses de données, le compromis est la surcharge relativement élevée de création et de communication. Ne créez pas des milliers d'Isolates—généralement quelques Isolates suffisent. Pour les tâches liées aux E/S, utiliser async/await est le meilleur choix.

autres extensions