Flutter常驻Isolate发送消息报ReceivePort非法参数错误求助

• 跨Isolate传参违反消息传输规则
  Dart的Isolate是内存隔离的，跨Isolate发送的消息仅支持传输可序列化的纯数据、SendPort，不允许传输ReceivePort（无论直接持有还是嵌套间接持有）、绑定Isolate本地资源的对象（包括Flutter UI层的RenderObject、Element、BuildContext、Canvas、闭包回调、原生资源句柄等）。
  你抛出异常的直接原因是：调用_isolatePort!.send()时传入的Tuple中，model或projectionData对象间接持有了ReceivePort引用——最常见的场景是直接把RenderObject或其关联的UI对象塞进了传参，这类UI对象内部隐式持有主Isolate的UI事件通信端口（本质就是ReceivePort），因此被Isolate消息机制拦截报错。
• Isolate实现存在设计缺陷
  你当前的常驻Isolate逻辑有两个明显问题：
  1. 每次调用project都会给广播流新增一个监听回调，多次调用后会堆积大量冗余监听，导致结果错乱、内存泄漏
  2. 没有做请求和响应的匹配标识，并发调用时无法将返回结果和发起的请求对应
• 调用时机错误
  你在RenderObject的paint同步方法内直接await异步计算，paint是每一帧都会触发的同步执行逻辑，在其中发起异步任务会导致重复发起大量计算请求，同时容易携带上下文中的UI资源引用。

分三步处理：

1. 清理跨Isolate传参，仅传输纯数据 #

传给子Isolate的所有参数必须是不含任何资源引用的纯Dart对象：

• 移除model、projectionData中所有对UI对象、回调函数、资源句柄的引用，仅保留计算必需的基础类型值（num、String、bool、List/Map集合、无资源引用的普通Dart类）
• 如果需要从UI对象中取计算参数，提前把需要的数值、属性抽出来组装成纯数据对象再传输，绝对不要直接传RenderObject、BuildContext这类UI层实例
• 子Isolate计算完成后返回的结果也必须是纯数据，主Isolate拿到结果后再做后续组装、UI更新操作

2. 重构常驻Isolate实现，修复逻辑缺陷 #

重构后的代码解决重复监听、请求响应匹配问题，参考实现如下：

import 'dart:async';
import 'dart:isolate';

// 内部请求封装，携带唯一请求ID做匹配
class _ProjectionRequest {
  final int requestId;
  final ObjectModel model;
  final ProjectionData projectionData;
  _ProjectionRequest(this.requestId, this.model, this.projectionData);
}

// 内部响应封装，携带对应请求ID
class _ProjectionResponse {
  final int requestId;
  final ObjectModel result;
  _ProjectionResponse(this.requestId, this.result);
}

class ProjectionWorker {
  Isolate? _isolate;
  ReceivePort? _workerPort;
  SendPort? _isolatePort;
  // 待完成请求映射表，key为请求ID
  final Map<int, Completer<ObjectModel>> _pendingRequests = {};
  int _requestIdCounter = 0;
  bool _isInitializing = false;

  // 初始化Isolate，全局只执行一次
  Future<void> _ensureIsolateReady() async {
    if (_isolate != null) return;
    if (_isInitializing) {
      while (_isolatePort == null) {
        await Future.delayed(const Duration(milliseconds: 10));
      }
      return;
    }
    _isInitializing = true;
    _workerPort = ReceivePort();
    _isolate = await Isolate.spawn<SendPort>(
      _isolateEntry,
      _workerPort!.sendPort,
      debugName: "flutter_object calculations",
    );
    // 全局只注册一次消息监听
    _workerPort!.listen((message) {
      if (message is SendPort) {
        _isolatePort = message;
        return;
      }
      if (message is _ProjectionResponse) {
        final completer = _pendingRequests.remove(message.requestId);
        completer?.complete(message.result);
      }
    });
    // 等待子Isolate通信端口就绪
    while (_isolatePort == null) {
      await Future.delayed(const Duration(milliseconds: 10));
    }
    _isInitializing = false;
  }

  Future<ObjectModel> project(
    ObjectModel model,
    ProjectionData projectionData,
  ) async {
    await _ensureIsolateReady();
    final requestId = _requestIdCounter++;
    final completer = Completer<ObjectModel>();
    _pendingRequests[requestId] = completer;
    _isolatePort!.send(_ProjectionRequest(requestId, model, projectionData));
    return completer.future;
  }

  // 组件销毁时释放Isolate资源
  void dispose() {
    _isolate?.kill();
    _workerPort?.close();
    _isolate = null;
    _workerPort = null;
    _isolatePort = null;
    _pendingRequests.clear();
  }
}

// 子Isolate运行入口
void _isolateEntry(SendPort mainSendPort) async {
  final isolateReceivePort = ReceivePort();
  mainSendPort.send(isolateReceivePort.sendPort);

  await for (final event in isolateReceivePort) {
    if (event is _ProjectionRequest) {
      // 执行数值计算逻辑，所有入参均为纯数据可直接使用
      final ObjectModel calcResult = _runProjectionCalculation(
        event.model,
        event.projectionData,
      );
      // 将结果和请求ID一起回传主Isolate
      mainSendPort.send(_ProjectionResponse(event.requestId, calcResult));
    }
  }
}

// 抽离纯计算逻辑
ObjectModel _runProjectionCalculation(ObjectModel model, ProjectionData data) {
  // 此处编写大量数值计算逻辑
  // ...
  return computedResult;
}

3. 修正调用时机，不要在paint方法内发起异步计算 #

paint是同步执行的帧绘制回调，仅做同步绘制操作，不要在其中发起异步任务：

• 提前在数据更新、布局阶段触发投影计算，计算完成后调用markNeedsPaint()触发重绘
• paint方法中直接使用已经计算完成的缓存结果做绘制
  参考调用示例：

class CustomProjectionRenderObject extends RenderObject {
  ObjectModel? _projectedObject;
  final ProjectionWorker _worker = ProjectionWorker();
  bool _isCalculating = false;

  // 数据更新时调用该方法触发计算，不要在paint里调用
  Future<void> updateProjection(
    ObjectModel rawModel,
    ProjectionData rawData,
  ) async {
    if (_isCalculating) return;
    _isCalculating = true;
    try {
      // 提前将原始对象转换为纯数据，移除所有UI/资源引用
      final pureModel = _extractPureModelData(rawModel);
      final pureData = _extractPureProjectionData(rawData);
      _projectedObject = await _worker.project(pureModel, pureData);
      markNeedsPaint(); // 计算完成后标记需要重绘
    } finally {
      _isCalculating = false;
    }
  }

  @override
  void paint(PaintingContext context, Offset offset) {
    final canvas = context.canvas;
    // 未计算完成时直接返回或绘制占位，不做异步等待
    if (_projectedObject == null) return;
    // 使用已缓存的计算结果做同步绘制
    // canvas.drawXXX(...)
  }

  @override
  void dispose() {
    _worker.dispose();
    super.dispose();
  }
}

排查传参问题时可以先做最小验证：调用send时仅传入基础类型（如整数、字符串），如果不再报错，说明原有传参中确实存在非法引用，逐个排查字段移除非纯数据内容即可。

内容的提问来源于stack exchange，提问作者samir.a.ts