Dart的”多线程“

众所周知，Dart是一门单线程的语言，我们可以将一些需要等待的任务放到异步操作中，但是异步任务必须等到线程空闲时才会去执行，这是无法满足我们某些场景的需求的。那Dart就没有办法实现类似子线程的功能吗？而实际，Dart其实是有办法实现类似多线程的功能的。

Isolate

Isolate调用

Isolate是一个非常底层的api，我们可以通过Isolate.spawn()方法进行调用。

void isolateTest() async {
  print("外部代码 1");
  Isolate.spawn(isoFunc0, "msg");
  print("外部代码 2");
}

void isoFunc0(String message) {
  // 模拟耗时操作
  sleep(Duration(seconds: 2));
  
  print("message is $message");
}

执行结果为

flutter: 外部代码 1
flutter: 外部代码 2
flutter: message is msg

Isolate与异步操作的区别

我们知道异步操作并没有开辟一条子线程，而是在线程空闲时去执行异步操作。而Isolate不同，我们可以通过下面代码看到区别。

void isolateTest() async {
  print("外部代码 1");
  Isolate.spawn(isoFunc0, "msg");
  sleep(Duration(seconds: 3));
  print("外部代码 2");
}

void isoFunc0(String message) {
  print("message is $message");
}

执行结果为：

flutter: 外部代码 1
flutter: message is msg
flutter: 外部代码 2

可以看到，尽管主线程中有任务执行没有空闲，但是Isolate.spawn的操作仍然执行了，这是异步操作所不具备的。

Isolate不是严格意义上的多线程

实际上，Isolate更像是进程而不是线程，因为他拥有独立的内存空间，并且他与子线程之间的通信需要借助到端口（Port）概念的api，这些特性让它看起来更像是进程。

我们通过代码验证一下：

String _data = "0";

void isolateTest() async {
  print("外部代码 1");
  Isolate.spawn(isoFunc0, "msg");
  sleep(Duration(seconds: 3));
  print("data is $_data");
  print("外部代码 2");
}

void isoFunc0(String message) {
  _data = message;
  print("message is $_data");
}

结果为：

flutter: 外部代码 1
flutter: message is msg
flutter: data is 0
flutter: 外部代码 2

可以看到，尽管Isolate中修改了_data的值，但是外部的_data的值并没有随之改变，显然，这个结果明显不符合多线程的特性。

ReceivePort

如果我们需要将Isolate的结果返回，我们需要使用端口ReceivePort来进行传递。我们将ReceivePort作为参数传递给Isolate，Isolate执行完成后通过Port的send方法将结果传递出来，外部通过listen得到结果。

void isolateTest() async {
  print("外部代码 1");
  ReceivePort port = ReceivePort();
  Isolate iso = await Isolate.spawn(isoFunc, port.sendPort);
  port.listen((message) {
    _data = message;
    print("data is $_data");
    port.close();
    iso.kill();
  });
  print("外部代码 2");

}

void isoFunc(SendPort port) {
  sleep(Duration(seconds: 2));
  port.send("msg");

}

执行结果为：

flutter: 外部代码 1
flutter: 外部代码 2
flutter: data is msg

port.listen到结果后，我们要将端口关闭，杀死Isolate。

compute

除了Isolate，Dart还给我们提供compute接口。

查看compute定义：

final _ComputeImpl compute = _isolates.compute;

可以猜测compute是对Isolates的封装，继续点进去：

Future<R> compute<Q, R>(isolates.ComputeCallback<Q, R> callback, Q message, { String debugLabel }) async {
  debugLabel ??= kReleaseMode ? 'compute' : callback.toString();
  final Flow flow = Flow.begin();
  Timeline.startSync('$debugLabel: start', flow: flow);
  final ReceivePort resultPort = ReceivePort();
  final ReceivePort errorPort = ReceivePort();
  Timeline.finishSync();
  final Isolate isolate = await Isolate.spawn<_IsolateConfiguration<Q, FutureOr<R>>>(
    _spawn,
    ... ...

可以确定，compute是对Isolate的封装。

compute的调用

compute的使用要比Isolate方便很多

void computeTest() async {
  print("外部代码 1");

  compute(computeFunc, "msg").then((value) => print("value = $value"));

  print("外部代码 2");
}

String computeFunc(String message) {
  print("computeFunc ${message}");
  return message + "compute";
}

执行结果为：

flutter: 外部代码 1
flutter: 外部代码 2
flutter: computeFunc msg
flutter: value = msgcompute

compute显然比Isolate更加方便简洁。

总结

尽管Isolate和compute为我们提供了类似多线程的功能，但实际上它更像是进程不是线程，频繁使用明显会消耗内存，所以我们一般只用来处理复杂耗时的计算，而像网络请求和文件读写，我们通过异步操作就可以解决我们的需求了。