Конкурентность и изоляты в 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

Пример

import 'dart: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 и без них.

Пример

// Выполнить ресурсоёмкую задачу в основном Isolate (заблокирует)
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 и т. д.); функции или замыкания нельзя передавать.

Двусторонняя связь

Пример

import 'dart:isolate';

// Рабочая функция, которая выполняется в новом 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(), значительно упростив использование одноразовых вычислительных задач.

Пример

import 'dart:isolate';

// Трудоёмкая функция вычисления
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.

Другие расширения