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