Flutter Isolates的工作原理、使用方法和最佳实践

// 示例：双向通信的基本设置
import 'dart:isolate';

void main() async {
  // 主 Isolate 创建接收端口
  ReceivePort mainReceivePort = ReceivePort();
  
  // 创建新 Isolate，并将主 Isolate 的 SendPort 传给它
  await Isolate.spawn(newIsolateEntry, mainReceivePort.sendPort);

  // 监听来自新 Isolate 的消息
  mainReceivePort.listen((message) {
    if (message is SendPort) {
      // 收到新 Isolate 发来的 SendPort，保存它以便后续向其发送消息
      SendPort newIsolateSendPort = message;
      newIsolateSendPort.send('Hello from main isolate!');
    } else {
      print('Main received: $message');
    }
  });
}

void newIsolateEntry(SendPort mainSendPort) {
  // 新 Isolate 创建自己的接收端口
  ReceivePort newReceivePort = ReceivePort();
  
  // 将自己的 SendPort 发送给主 Isolate
  mainSendPort.send(newReceivePort.sendPort);

  // 监听来自主 Isolate 的消息
  newReceivePort.listen((message) {
    print('New isolate received: $message');
    mainSendPort.send('Hello back from new isolate!');
  });
}

import 'package:flutter/foundation.dart';

// 必须是顶级或静态函数
int calculateFactorial(int n) {
  if (n <= 1) return 1;
  int result = 1;
  for (int i = 2; i <= n; i++) {
    result *= i;
  }
  return result;
}

void main() async {
  // 使用 compute 在后台计算阶乘
  int result = await compute(calculateFactorial, 100000);
  print('Factorial result: $result');
}

import 'dart:isolate';

void main() async {
  ReceivePort receivePort = ReceivePort();
  
  // 1.  spawn 一个新的 Isolate
  Isolate newIsolate = await Isolate.spawn(
    heavyTask, // 要在新 Isolate 中执行的函数
    receivePort.sendPort, // 初始消息，通常是主 Isolate 的 SendPort
  );

  // 2. 监听来自新 Isolate 的消息
  receivePort.listen((message) {
    print('Received: $message');
    // 收到结果后，可以关闭端口和 Isolate
    receivePort.close();
    newIsolate.kill(priority: Isolate.immediate);
  });
}

// 新 Isolate 的入口函数
void heavyTask(SendPort mainSendPort) {
  // 执行繁重任务...
  int sum = 0;
  for (int i = 0; i < 1000000000; i++) {
    sum += i;
  }
  
  // 将结果发送回主 Isolate
  mainSendPort.send(sum);
}

import 'dart:isolate';

Future<void> main() async {
  int number = 1000000000;
  
  // 使用 Isolate.run
  int result = await Isolate.run(() {
    // 这个函数在新 Isolate 中执行
    int sum = 0;
    for (int i = 0; i < number; i++) {
      sum += i;
    }
    return sum; // 返回值会被自动发送回主 Isolate
  });
  
  print('Sum: $result');
}

import 'dart:isolate';

void main() async {
  ReceivePort mainReceivePort = ReceivePort();
  Isolate isolate = await Isolate.spawn(worker, mainReceivePort.sendPort);

  // 首先等待 worker 将其 SendPort 发送过来
  SendPort? workerSendPort;
  mainReceivePort.listen((message) {
    if (message is SendPort) {
      workerSendPort = message;
      // 收到 worker 的端口后，开始发送任务
      workerSendPort?.send('Start processing');
    } else if (message == 'Task done') {
      print('Worker reported task completion.');
      // 处理完成...
      mainReceivePort.close();
      isolate.kill();
    }
  });
}

void worker(SendPort mainSendPort) {
  ReceivePort workerReceivePort = ReceivePort();
  // 首先将自己的 SendPort 发送给主 Isolate
  mainSendPort.send(workerReceivePort.sendPort);

  workerReceivePort.listen((message) {
    if (message == 'Start processing') {
      // 执行任务...
      // ...
      // 任务完成后通知主 Isolate
      mainSendPort.send('Task done');
    }
  });
}

import 'dart:isolate';
import 'dart:typed_data';
import 'package:flutter/foundation.dart'; // 用于 compute

Future<Uint8List> applyFilterToImage(Uint8List imageData) async {
  // 使用 compute 简化图像滤镜应用
  return await compute(_applyFilter, imageData);
}

Uint8List _applyFilter(Uint8List imageData) {
  // 这是一个模拟的耗时图像处理函数
  // 真实场景中可能会应用复杂的卷积核（如高斯模糊、锐化等）
  Uint8List processedData = Uint8List.fromList(imageData);
  for (int i = 0; i < processedData.length; i += 4) { // 假设 RGBA
    // 简单示例：将图像转换为灰度图
    int r = processedData[i];
    int g = processedData[i + 1];
    int b = processedData[i + 2];
    int gray = (r * 0.299 + g * 0.587 + b * 0.114).round();
    processedData[i] = gray;
    processedData[i + 1] = gray;
    processedData[i + 2] = gray;
  }
  return processedData;
}

// 在 Widget 中使用
void _processImage() async {
  setState(() => _isProcessing = true);
  try {
    final processedImageData = await applyFilterToImage(_originalImageData);
    setState(() => _processedImage = Image.memory(processedImageData));
  } finally {
    setState(() => _isProcessing = false);
  }
}

import 'dart:convert';
import 'package:flutter/foundation.dart';

Future<Map<String, dynamic>> parseLargeJson(String jsonString) async {
  return await compute(_parseJson, jsonString);
}

Map<String, dynamic> _parseJson(String jsonString) {
  return jsonDecode(jsonString); // jsonDecode 对于巨大字符串可能很耗时
}

// 计算斐波那契数列（非常耗时的实现，仅作示例）
int fibonacci(int n) {
  if (n < 2) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

void _calculateFibonacci() async {
  setState(() => _isCalculating = true);
  final result = await compute(fibonacci, 40); // 计算第40项
  setState(() {
    _result = result;
    _isCalculating = false;
  });
}

import 'dart:isolate';
import 'dart:io';
import 'package:archive/archive.dart'; // 假设使用 archive 库

Future<File> compressFileInBackground(File inputFile) async {
  return await Isolate.run(() async {
    // 读取文件内容
    List<int> bytes = await inputFile.readAsBytes();
    // 创建压缩器（例如 GZip）
    List<int> compressedBytes = GZipEncoder().encode(bytes);
    // 写入压缩文件
    File outputFile = File('${inputFile.path}.gz');
    await outputFile.writeAsBytes(compressedBytes);
    return outputFile;
  });
}