Конкурентность и изоляты в Dart
Конкурентность — это способность одновременно обрабатывать несколько задач.
Модель конкурентности Dart отличается от традиционной многопоточности; в ней используются изоляты для достижения параллельных вычислений.
В этой главе рассматриваются модель конкурентности Dart, понятие и использование изолятов, а также механизм передачи сообщений.
Модель конкурентности Dart
Большинство языков программирования используют многопоточную модель с общей памятью, где несколько потоков разделяют одно и то же пространство памяти.
Недостаток этой модели в том, что она подвержена состояниям гонки и взаимным блокировкам.
Dart применяет другую стратегию:Каждый изолят имеет собственную независимую кучу памятиИзоляты не разделяют память.
Они взаимодействуют посредством передачи сообщений, что принципиально позволяет избежать проблем гонок данных.
Модель конкурентности Dart имеет три уровня:
| Уровень | Механизм | Применимые сценарии |
|---|---|---|
| Цикл событий | Однопоточная асинхронность (цикл событий) | Операции ввода-вывода, таймеры и взаимодействие с пользователем. |
| Isolate | Изолированная память + передача сообщений | Вычисления с высокой нагрузкой на CPU |
| Future/Stream | Синтаксис асинхронного программирования | Большинство повседневных сценариев разработки |
Потребности в конкурентности большинства программ на Dart можно удовлетворить с помощью async/await и Future/Stream. Изоляты нужны только тогда, когда требуется выполнять тяжёлые вычисления, ограниченные производительностью CPU. Преждевременное использование изолятов усложняет код без особой выгоды.
Понятие и использование Isolate
Isolate — это единица параллелизма в Dart, и каждый Isolate имеет собственную независимую память и цикл событий.
Главная программа сама выполняется в Isolate (главном Isolate).
Используйте Isolate.spawn для создания нового Isolate
Пример
// Эта функция будет выполняться в новом Isolate
// SendPort используется для отправки сообщений главному Isolate
void heavyComputation(SendPort sendPort) {
print('Новый Isolate начинает вычисления...');
// Имитация вычислений, интенсивно использующих CPU
int sum = 0;
for (int i = 1; i <= 10000000; i++) {
sum += i;
}
// Отправить результат вычисления обратно в главный Isolate
sendPort.send(sum);
print('Вычисление в новом Isolate завершено, результат отправлен');
}
Future<void> main() async {
print('Главный Isolate запущен');
// Создайте ReceivePort для приёма сообщений
var receivePort = ReceivePort();
// spawn создаёт новый Isolate
await Isolate.spawn(heavyComputation, receivePort.sendPort);
print('Главный Isolate может заниматься другими делами, пока ждёт результат...');
// Дождитесь результата вычисления от нового Isolate
var result = await receivePort.first;
print('ПРИМЕР результата вычисления: сумма от 1 до 10000000 = $result');
receivePort.close();
print('Основной Isolate завершён');
}
主 Isolate 启动 主 Isolate 在等待结果的同时可以做其他事情... 新 Isolate 开始计算... 新 Isolate 计算完成,结果已发送 EXAMPLE 计算结果: 1 到 10000000 的和 = 50000005000000 主 Isolate 结束
Сравнение: различия в производительности с Isolates и без них.
Пример
int fibonacci(int n) {
if (n <= 1) return n;
return fibonacci(n - 1) + fibonacci(n - 2);
}
void main() {
// Вычисления в основном Isolate — заблокирует все остальные операции
var startTime = DateTime.now();
// Примечание: если n слишком велико, это вычисление займёт очень много времени.
// В реальной разработке такие вычисления следует помещать в отдельный Isolate.
var result = fibonacci(40);
var elapsed = DateTime.now().difference(startTime);
print('ПРИМЕР Fibonacci(40) = $result');
print('Затраченное время: ${elapsed.inMilliseconds}ms');
print('(Примечание: во время вычисления главный Isolate не может обрабатывать другие задачи)');
}
В приложениях Flutter, если в главном Isolate выполняется длительное синхронное вычисление, это приведёт к зависанию UI. Решение — поместить задачу вычисления в отдельный Isolate, а после завершения вычисления отправить результат обратно через сообщения и обновить UI.
Механизм передачи сообщений
Экземпляры Isolate взаимодействуют путём передачи сообщений через SendPort и ReceivePort.
Сообщения должны быть сериализуемыми (примитивные типы, String, List, Map и т. д.); функции или замыкания нельзя передавать.
Двусторонняя связь
Пример
// Рабочая функция, которая выполняется в новом Isolate
void workerIsolate(SendPort mainSendPort) {
// Создать собственный ReceivePort для получения сообщений от главного Isolate
var workerReceivePort = ReceivePort();
// Сначала отправьте SendPort воркера главному Isolate, чтобы установить двусторонний канал
mainSendPort.send(workerReceivePort.sendPort);
print('Рабочий изолят: ожидание задач...');
// Слушать задачи, отправленные главным изолятом
workerReceivePort.listen((message) {
if (message is List<int>) {
// Получена задача: возвести каждое число в списке в квадрат
print('Рабочий изолят: получены данные $message');
var result = message.map((n) => n * n).toList();
// Отправить результат обратно через mainSendPort
mainSendPort.send(result);
} else if (message == 'exit') {
print('Рабочий изолят: получен сигнал выхода, завершение работы');
workerReceivePort.close();
mainSendPort.send('до свидания');
}
});
}
Future<void> main() async {
print('Главный изолят: запуск');
// Создать главный порт приёма
var mainReceivePort = ReceivePort();
// Запустить рабочий изолят
await Isolate.spawn(workerIsolate, mainReceivePort.sendPort);
// Дождаться, пока рабочий отправит свой SendPort (установить двустороннюю связь)
SendPort? workerSendPort;
await for (var msg in mainReceivePort) {
if (msg is SendPort) {
workerSendPort = msg;
print('Основной изолят: двусторонняя связь с Worker установлена');
break;
}
}
// Отправить задачу через SendPort Worker
workerSendPort!.send([1, 2, 3, 4, 5]);
workerSendPort.send([10, 20, 30]);
// Получить результат вычислений Worker
int responseCount = 0;
await for (var msg in mainReceivePort) {
if (msg is List<int>) {
print('Основной изолят: получен результат $msg');
responseCount++;
if (responseCount == 2) break;
}
}
// Отправить сигнал выхода
workerSendPort.send('exit');
await for (var msg in mainReceivePort) {
if (msg == 'goodbye') {
print('Главный изолят: рабочий изолят завершился');
break;
}
}
mainReceivePort.close();
print('ПРИМЕР: демонстрация двусторонней связи завершена');
}
主 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 双向通信演示结束
Упрощение с помощью Isolate.run (Dart 3.0+)
Dart 3.0 представил Isolate.run(), значительно упростив использование одноразовых вычислительных задач.
Пример
// Трудоёмкая функция вычисления
int complexCalculation(int n) {
int result = 0;
for (int i = 0; i < n; i++) {
result += i * i;
}
return result;
}
Future<void> main() async {
print('Начинаем вычисление...');
// Isolate.run: одна строка кода, автоматически создаёт Isolate, выполняет и возвращает результат
var result = await Isolate.run(() => complexCalculation(10000000));
print('ПРИМЕР результата вычисления: $result');
print('Вычисление завершено');
// Сравнение: если не использовать Isolate
print('(Если вычислять напрямую в основном Isolate, это заблокирует другие операции)');
}
开始计算... EXAMPLE 计算结果: 333333283333335000000 计算完成 (如果在主 Isolate 中直接计算,会阻塞其他操作)
Isolate.run() подходит для сценариев, когда нужно «выполнить вычисление один раз и вернуть результат». Если требуется постоянная двусторонняя связь (например, длительно работающий фоновый сервис), нужно использовать Isolate.spawn() + SendPort/ReceivePort.
Ограничения передачи сообщений в Isolate.
| Можно передавать | Нельзя передавать |
|---|---|
| null、bool、int、double、String | Функции, замыкания |
| List, Map, Set (элементы также можно передавать) | Stream、Future |
| SendPort (используется для установления цепочки связи). | Большинство объектов непримитивных типов |
| Capability (токен разрешения) | Файловые дескрипторы, сетевые сокеты |
| TransferableTypedData (эффективно передаёт большие фрагменты данных) | Пользовательские классы (кроме сериализуемых) |
Сравнение моделей конкурентности
| Особенности | Dart Isolate | Традиционная многопоточность (например, Java) |
|---|---|---|
| Модель памяти | Независимая память, без совместного использования | Общая память |
| Способ коммуникации | Передача сообщений (SendPort) | Общие переменные + блокировки |
| Гонка данных | Не существует (нет совместного использования) | Требует защиты с помощью механизма блокировок |
| Риск взаимной блокировки | Практически отсутствует | Exists |
| Накладные расходы на создание | Относительно большие | Относительно малые |
| Применимые сценарии | Параллельные вычисления с высокой нагрузкой на CPU | Общая конкурентность |
Другие расширенияХотя модель Isolate в Dart позволяет избежать гонок данных, обратной стороной являются относительно высокие накладные расходы на создание и обмен данными. Не создавайте тысячи Isolate — обычно достаточно нескольких Isolate. Для задач, ограниченных вводом-выводом, лучшим выбором будет использование async/await.