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 :
| Niveau | Mécanisme | Scénarios applicables |
|---|---|---|
| Boucle d'événements | Asynchrone monothread (boucle d'événements) | Les opérations d'E/S, les minuteurs et l'interaction utilisateur. |
| Isolate | Mémoire isolée + passage de messages | Calcul intensif sur le CPU |
| Future/Stream | Syntaxe de programmation asynchrone | La 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
// 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
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
// 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
// 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 transmis | Ne peut pas être transmis |
|---|---|
| null, bool, int, double, String | Fonctions, 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és | Isolate Dart | Multithreading traditionnel (par ex., Java) |
|---|---|---|
| Modèle de mémoire | Mémoire indépendante, aucun partage | Mémoire partagée |
| Méthode de communication | Passage de messages (SendPort) | Variables partagées + verrous |
| Course aux données | N'existe pas (pas de partage) | Nécessite une protection par mécanisme de verrouillage |
| Risque d'interblocage | Quasiment inexistant | Exists |
| Surcoût de création | Relativement important | Relativement faible |
| Scénarios applicables | Calcul parallèle intensif en CPU | Concurrence générale |
autres extensionsBien 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.