【Flutter 异步编程 – 捌】 | 计算耗时？ Isolate 来帮忙

本文为稀土技术社区首发签约文章，14天内制止转载，14天后未获授权制止转载，侵权必究！

张风捷特烈 – 出品

一、问题引进 – 核算密集型使命

假设现在有个需求，我想要核算 1 亿 个 1~10000 间随机数的平均值，在界面上显现成果，该怎么办?
可能有小伙伴踊跃发言：这还不简略，生成 1 亿 个随机数，算呗。

1. 搭建测验场景

如下，写个简略的测验界面，界面中有核算成果和耗时的信息。点击运行按钮，触发 _doTask 办法进行运算。核算完后将成果展现出来：

代码详见：【async/isolate/01】

void _doTask() {
  int sum = 0;
  int startTime = DateTime.now().millisecondsSinceEpoch;
  for(int i = 0;i<count;i++){
    sum += random.nextInt(10000);
  }
  int endTime = DateTime.now().millisecondsSinceEpoch;
  result = sum/count;
  cost =  endTime - startTime;
  setState(() {});
}

能够看到，这样是能够完结需求的，总耗时在 8.5 秒左右。细心的朋友可能会发现，在点击按键触发 _doTask 时，FloatingActionButton 的水波纹并没有出现，仿佛是卡死一般。为了应证这点，咱们再进行一个比照试验。

请点击前	请点击后

2. 核算耗时堵塞

如下所示，咱们让 CupertinoActivityIndicator 一直处于运动状况，作为界面 未被卡死 的标志。当点击运行时，能够看出指示器被卡住了, 再点击按钮也没有任何的水波纹反映，这说明：

核算的耗时使命会堵塞 Dart 的线程，界面因此无法有任何呼应。

未履行前	履行前后

Row(
  mainAxisAlignment: MainAxisAlignment.center,
  children: const [Text("动画指示器暗示: "), CupertinoActivityIndicator()],
),

3. 核算耗时堵塞的解决方案

有人说，用异步的办法触发 _doTask 呗，比方用 Future 和 scheduleMicrotask 包一下，或 Stream 异步处理。有这个主意的人能够试一试，假如你看懂前面几篇看到了原理，就知道是不可行的，这些东西只不过是回调包装而已。只需核算的使命仍是 Dart 在单线程中处理的，就无法防止堵塞。现在的问题相当于：

一个人无法一起做 洗漱 和 扫地 的使命。

一旦堵塞，界面就无法有任何呼应，自然也无法展现加载中的动画，这关于用户体验来说是极端糟糕的。那怎么让核算密集型的耗时使命，在处理时不堵塞呢？咱们能够好好品味一下这句话：

这句话言外之意给出了两种解决方案：

【1】. 将核算密集型的耗时使命，从 Dart 端剥离，交由 其他机体 来处理。
【2】. 在 Dart 中经过 多线程 的办法处理，然后不堵塞主线程。

办法一其实很好了解，比方耗时的使命交由服务端来完结，客户端经过 接口恳求 ，获取呼应成果。这样核算型的密集使命，关于 Flutter 而言，就转化成了一个网络的 IO 使命。或许经过 插件 的办法，将核算的耗时使命交由平台来经过多线程处理，而 Dart 端只需求经过回调处理即可，也不会堵塞。

办法一处理的本质上都是将核算密集型的使命转移到其他机体中，然后让 Dart 防止处理核算密集型的耗时使命。这种办法需求其他言语或后端的支持，想要完结是有必定门槛的。那怎么直接在 Flutter 中，经过 Dart 言语处理核算密集型的使命呢？

这便是咱们今天的主角: Isolate 。可能许多人潜意识里 Dart 是单线程模型，无法经过多线程的处理使命，这种认知就狭窄了。其实 Dart 提供了 Isolate, 本质上是经过 C++ 创立线程，阻隔出另一份区间来经过 Dart 处理使命。它相当于线程的一种上层封装，屏蔽了许多内部细节，能够经过 Dart 言语直接操作。

二、从 compute 函数知道 Isolate

首要，咱们经过 compute 函数知道一下核算密集型的耗时使命该怎么处理。 compute 函数字如其名，用于处理核算。只需简略看一下，就知道它本身是 Isolate 的一个简略的封装运用办法。它作为全局函数被界说在 foundation/isolates.dart 中：

1. 知道 compute 函数

既然是函数，那运用时就十分简略，调用就行了。关于函数的调用，比较重要的是 入参 、回来值 和 泛型。从上面函数界说中能够看出，它便是 isolate 包中的 compute 函数, 其间泛型有两个 Q 和 R ,回来值是 R 泛型的 Future 目标，很明显该泛型表明成果 Result；第二入参是 Q 泛型的 message ，表明音讯类型；第三入参是可选参数，用于调试时的标签。

---->[_isolates_io.dart#compute]----
/// The dart:io implementation of [isolate.compute].
Future<R> compute<Q, R>(
    isolates.ComputeCallback<Q, R> callback, 
    Q message, 
    { String? debugLabel }) 
async {

看到这儿，很自然地就能够想到，这儿榜首参中传入的 callback 便是核算使命，它将被在其他的 isolate 中被履行，然后回来核算成果。下面咱们来看一下在当前场景下的运用办法。在此之前，先封装一下回来的成果。经过 TaskResult 记载成果，作为 compute 的回来值：

代码详见：【async/isolate/02_compute】

class TaskResult {
  final int cost;
  final double result;
  TaskResult({required this.cost, required this.result});
}

2. compute 函数的运用

在 compute 办法在传入两个参数，其一是 _doTaskInCompute ，也便是核算的耗时使命，其二是传递的信息，这儿不需求，传空值字符串。虽然办法的泛型能够不传，但严谨一些的话，可也以把泛型加上，这样可读性更好一些：

void _doTask() async {
  TaskResult taskResult = await compute<String, TaskResult>(
      _doTaskInCompute, '',
      debugLabel: "task1");
  setState(() {
    result = taskResult.result;
    cost = taskResult.cost;
  });
}

关于 compute 而言，传入的回调有一个十分重要的留意点:

函数必须是 静态函数 或许 全局函数

static Random random = Random();
static Future<TaskResult> _doTaskInCompute(String arg) async {
  int count = 100000000;
  double result = 0;
  int cost = 0;
  int sum = 0;
  int startTime = DateTime.now().millisecondsSinceEpoch;
  for (int i = 0; i < count; i++) {
    sum += random.nextInt(10000);
  }
  int endTime = DateTime.now().millisecondsSinceEpoch;
  result = sum / count;
  cost = endTime - startTime;
  return TaskResult(
    result: result,
    cost: cost,
  );
}

下面看一下用和不必 compute 处理的效果差异，如下左图是运用 compute 的效果，在进行核算的一起指示器的动画仍在运动，桌面核算操作并未影响主线程，界面仍能够触发呼应，这就和前面产生了明显的比照。

用 compute	不必 compute

3. 了解 compute 的效果

如下，在 _doTaskInCompute 中打断点调试一下，能够看出此时除了 main 还有一个 task1 的栈帧。此时断点停留在新帧中， main 仍处于运行状况：

这就相当于核算使命不想自己处理，找另外一个人来做。每块处理使命的单元，就能够视为一个 isolate。它们之间的信息数据在内存中是不互通的，这也是为什么起名为 阻隔 isolate 的原因。这种特功能十分有效地防止多线程中操作同一内存数据的危险。但一起也需求引进一个 通讯机制 来处理两个 isolate 间的通讯。

其实这和 客户端 - 服务端 的模型十分相似，经过 发送端 SendPort 发送音讯，经过接纳端 RawReceivePort 接纳音讯。从 compute 办法的源码中能够简略地看出，其本质是经过 Isolate.spawn 完结的 Isolate 创立。

这儿有个小细节要留意，经过屡次测验发现 compute 中的核算耗时要普遍高于主线程中的耗时。这并不是说新建的 isolate 在核算能力上远小于 主 isolate, 毕竟这儿是 1 亿 次的核算，任何微小的细节都将被扩大 1 亿 倍。这儿的关注点应在于 新 isolate 能够独立于 主 isolate 运行，并且能够经过通讯机制将成果回来给 主 isolate 。

4. compute 参数传递与多个 isolate

假如是大量的彼此独立的核算耗时使命，能够敞开多个 isolate 一起处理，最后进行成果汇总。比方这儿 1 亿 次的核算，咱们能够开 2 个 isolate , 分别处理 5000 万 个核算使命。如下所示，总耗时便是 6 秒左右。当然创立 isolate 也是有资源消耗的，并不是说创立 100 个就能把耗时下降 100 倍。

关于传参十分简略，compute 榜首泛型是参数类型，这儿能够指定 int类型作为 _doTaskInCompute 使命的入参，指定核算的次数。这儿经过两个 compute 创立两个 isolate 一起处理 5000 万 个随机数的的平均值，来模仿那些彼此独立的使命：

代码详见：【async/isolate/03_compute】

最后经过 Future.await 对多个异步使命进行成果汇总，暗示图如下，这样就相当于又开了一个 isolate 进行处理核算使命：

关于 isolate 千万不要盲目运用，必定要认清当前使命是否真有必要运用。比方几百微秒就能处理完结的使命，用 isolate 便是拿导弹打蚊子。或许那些并非由 Dart 端处理的 IO 密集型 使命，用 isolate 就相当于你打开了烧水按钮，又找来一个人专门看着烧水的进程。这种多此一举的行为，都是关于异步不了解的体现。

一般而言，客户端中并没有太多需求处理杂乱核算的场景，只要一些特定场景的软件，比方需求进行大量的文字解析、杂乱的图片处理等。

三、剖析 compute 函数的源码完结

到这可能有人觉得，新开一个 isolate好简略啊，compute 函数处理一下就好啦。可是，简略必定有简略的 局限性，细心思考一下，会发现 compute 函数有个缺陷：它只会 "闷头干活"，只要使命完结才会经过 Future 告诉 main isolate 。

也便是说，关于 UI 界面来说无法无法感知到 使命履行进展 信息，处理展现 核算中... 之外没什么能干的。这在某些特别耗时的场景中会造成用户的等待焦虑，咱们需求让干活的 isolate 抽空告诉一下 main isolate，所以对 isolate 之间的通讯办法，是有必要了解的。

既然 compute 在完结使命时能够进行一次通讯，那么就能够从 compute 函数的源码中去剖析这种通讯的办法。

1. 接纳端口的创立与处理器设置

如下所示，在一开始会创立一个 Flow 目标，从该目标的成员中能够看出，它只担任维护两个整型 id 和 _type 的数值信息。接下来会创立 RawReceivePort 目标，是不是有点眼熟？

还记得那个经常在面前晃的 _RawRecivePortImpl类吗？ RawReceivePort 的默许工厂结构办法创立的便是 _RawReceivePortImpl 目标，如下代码所示：

---->[isolate_patch.dart/RawReceivePort]----
@patch
class RawReceivePort {
  @patch
  factory RawReceivePort([Function? handler, String debugName = '']) {
    _RawReceivePortImpl result = new _RawReceivePortImpl(debugName);
    result.handler = handler;
    return result;
  }
}

接下来，会创立一个 Completer 目标，并在为 port 设置信息的 handler 处理器，在处理回调中触发 completer#complete 办法，表明异步使命完结。也便是说处理器接纳信息之时，便是 completer 中异步使命完结之日。

假如不知道 Completer 和接纳端口设置 handler 是干嘛的，能够分别到【第五篇·第二节】和【第六篇·榜首节】温故，这儿就不赘述了。

---->[_isolates_io.dart#compute]----
final Completer<dynamic> completer = Completer<dynamic>();
port.handler = (dynamic msg) {
  timeEndAndCleanup();
  completer.complete(msg);
};

2. 知道 Isolate.spawn 办法

接下来会触发 Isolate.spawn 办法，该办法是生成 isolate 的核心。其间传入的 回调 callback 和 音讯 message 以及发送的端口 SendPort 会组合成 _IsolateConfiguration 作为第二参数：

经过 Isolate.spawn 办法的界说能够看出，榜首参是一个进口函数，第二参是函数入参。所以上面红框中的目标将作为 _spawn 函数的入参。从这儿能够看出榜首参 _spawn 函数应该是在新 isolate 中履行的。

external static Future<Isolate> spawn<T>(
    void entryPoint(T message), T message,
    {bool paused = false,
    bool errorsAreFatal = true,
    SendPort? onExit,
    SendPort? onError,
    @Since("2.3") String? debugName});

下面是在耗时使命中打断点的效果，其间很明晰地展现出 _spawn 办法到 _doTaskInCompute 的进程。

如下，是 _spawn 的处理流程，上面的调试发生在 127 行，此时触发回调办法，获取成果。然后在封闭 isolate 时，将成果发送出去，流程其实并不杂乱。

有一个小细节，成果经过 _buildSuccessResponse 办法处理了一下，封闭时发送的音讯是列表，后期会依据列表的长度判别使命处理的正确性。

List<R> _buildSuccessResponse<R>(R result) {
  return List<R>.filled(1, result);
}

3. 异步使命的完毕

从前面测验中能够知道 compute 函数回来值是一个泛型为成果的 Future 目标，那这个回来值是什么呢？如下能够看出当成果列表长度为 1 表明使命成功完结，回来 completer 使命成果的首元素：

再结合 completer 触发 complete 完结的机遇，就不难知道。最终的成果是由接纳端接纳到的信息，调试如下：

也便是说，isolate 封闭时发送的信息，将会被 接纳端的处理器 监听到。这便是 compute 函数源码的全部处理逻辑，总的来看仍是十分简略的。便是，运用 Completer ，根据 Isolate.spawn 的简略封装，屏蔽了用户对 RawReceivePort 的感知，然后简化运用。

四、Isolate 发送和接纳音讯的运用

经过 compute 函数咱们知道 isoalte 之间有着一套音讯 发送 - 监听 的机制。咱们能够利用这个机制在某些时刻发送进展音讯传给 main isolate，这样 UI 界面中就能够展现出 耗时使命 的进展。如下所示，每当 100 万次 核算时，发送音讯告诉 main isolate :

1. 运用 Isolate.spawn

compute 函数为了简化运用，将 发送 - 监听 的处理封装在了内部，用户无法操作。运用为了能运用该功能，咱们能够自动来运用 Isolate.spawn 。如下所示，创立 RawReceivePort，并设置 handler 处理器器，这儿经过 handleMessage 函数来单独处理。

代码详见：【async/isolate/04_spawn】

然后调用 Isolate.spawn 来敞开新 isolate，其间榜首参是在新 isolate 中处理的耗时使命，第二参是使命的入参。这儿将发送端口传入 _doTaskInCompute 办法，以便发送音讯：

void _doTask() async {
  final receivePort = RawReceivePort();
  receivePort.handler = handleMessage;
  await Isolate.spawn(
    _doTaskInCompute,
    receivePort.sendPort,
    onError: receivePort.sendPort,
    onExit: receivePort.sendPort,
  );
}

2. 经过端口发送音讯

SendPort 传入 _doTaskInCompute 中，如下 tag1 处，能够每隔 1000000 次发送一次进展告诉。在使命完结后，运用 Isolate.exit 办法封闭当前 isolate 并发送成果数据。

static void _doTaskInCompute(SendPort port) async {
  int count = 100000000;
  double result = 0;
  int cost = 0;
  int sum = 0;
  int startTime = DateTime.now().millisecondsSinceEpoch;
  for (int i = 0; i < count; i++) {
    sum += random.nextInt(10000);
    if (i % 1000000 == 0) { // tag1
      port.send(i / count);
    }
  }
  int endTime = DateTime.now().millisecondsSinceEpoch;
  result = sum / count;
  cost = endTime - startTime;
  Isolate.exit(port, TaskResult(result: result, cost: cost));
}

3. 经过接纳端处理音讯

接下来只需在 handleMessage 办法中处理发送端传递的音讯即可，能够依据音讯的类型判别是什么音讯，比方这儿假如是 double 表明是进展，告诉 UI 更新进展值。另外，假如不同类型的音讯十分多，也能够自己界说一套发送成果的标准便利处理。

void handleMessage(dynamic msg) {
  print("=========$msg===============");
  if (msg is TaskResult) {
    progress = 1;
    setState(() {
      result = msg.result;
      cost = msg.cost;
    });
  }
  if (msg is double) {
    setState(() {
      progress = msg;
    });
  }
}

其实学会了怎么经过 Isolate.spawn 处理核算耗时使命，以及经过 SendPort-RawReceivePort 处理 发送 - 监听 音讯，就能满意绝大多数对 Isolate 的运用场景。假如不需求在使命履行进程中发送告诉，运用 compute 函数会便利一些。最后仍是要强调一点，不要乱用 Isolate ，运用前动动脑子，思考一下是否真的是核算耗时使命，是否真的需求在 Dart 端来完结。开一个 isolate 至少要消耗 30 kb：

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。