dart中的isolate

isolate可以理解为dart中的线程，但它又不同于线程，准确的说应该叫做协程，协程最大的优势就是它具有极高的执行效率，因为携程中子程序的调用不需要线程的切换，所以对于线程数量越大的程序来说协程的优势就越明显。每个isolate都有自己独立的执行线程和事件循环，以及内存，所以isolate之间不存在锁竞争的问题，各个isolate之间通过消息通信。

root isolate

对于每一个flutter应用，当应用被启动时都会有一个默认的isolate，称为root isolate。我们自己的代码默认情况下都在这个isolate中执行。

消息循环

类似于iOS的NSRunLoop或者安卓的Looper，每个isolate内部都有一个消息循环，它随着isolate的创建自动开启，存在两个队列 event queue和microtask queue，后者优先级高于前者，提交到队列中的任务按照顺序依次执行。引用官方的一张图片

image.png

先看如下代码：

void function_main() async
{
  print("开始执行");
  Timer.run((){
    print("timer event 立即执行1");
  });
  Future.delayed(Duration(seconds:1),(){
    print("event 延迟2秒执行");
  });
  scheduleMicrotask((){
    print("micro task 立即执行1");
  });
  print("结束执行");
}

执行结果为：
flutter: 开始执行
flutter: 结束执行
flutter: micro task 立即执行1
flutter: timer event 立即执行1
flutter: event 延迟2秒执行
符合预期

接下来看如下一段代码：

void function_main() async
{
  print("开始执行");
  Timer.run((){
    print("timer event 执行1");
    scheduleMicrotask((){
      print("微任务2");
    });
  });
  scheduleMicrotask((){
    print("micro task 执行1");
    Timer.run(() {
      print("time event 执行2");
    });
  });
  print("结束执行");
}

运行结果如下：
flutter: 开始执行
flutter: 结束执行
flutter: micro task 执行1
flutter: timer event 执行1
flutter: 微任务2
flutter: time event 执行2
可以看到microtask 优先级比event要高，而且提交到队列中的任务是顺序执行的，一个任务执行完成后才会执行下一个任务

Future

Future用于异步任务，通过它可以创建到event loop和microtask队列中的任务去执行，请看如下一段代码

void function_main() async
{
  print("开始执行");

  Future future1 = new Future(() => null);
  future1.then((value){
    print("future1 执行then2");
  });
  future1.then((_) {
    print("future1 执行then");
  }).catchError((e) {
    print("future1 执行catchError");
  }).whenComplete(() {
    print("future1 执行whenComplete");
  });

  Future future2 = new Future((){
    print("future2 初始化任务");
  });

  future2.then((_) {
    print("future2 执行then");
    future1.then((_){
      print("future1 执行第三个then");
    });
  }).catchError((e) {
    print("future2 执行catchError");
  }).whenComplete(() {
    print("future2 执行whenComplete");
  });

  future1.then((_) {
    print("future1 执行第二个then");
  });

  Future future3 = Future((){
    print("future3 初始化");
  });

  Future future4 = Future.value("立即执行").then((value){
    print("future4 执行then");
  }).whenComplete((){
    print("future4 执行whenComplete");
  });
  print("main 结束");
}

执行结果为：
flutter: 开始执行
flutter: main 结束
flutter: future4 执行then
flutter: future4 执行whenComplete
flutter: future1 执行then2
flutter: future1 执行then
flutter: future1 执行whenComplete
flutter: future1 执行第二个then
flutter: future2 初始化任务
flutter: future2 执行then
flutter: future2 执行whenComplete
flutter: future1 执行第三个then
flutter: future3 初始化

分析
1、通过Future.value()函数创建的任务是立即执行的，所以就立即执行future4 执行then和future4 执行whenComplete
2、每一个Future可以通过then()注册多个回调，他们按照注册的顺序依次执行。当所有注册的then()执行完毕后接着会回调whenComplete。(备注：如果是在whenComplete之后注册的then，那么这个then的任务将放在microtask执行，所以这也就是为什么"future1 执行第三个then"在"future3 初始化"前执行的原因)，参考官方文档then的注释

* When this future completes with a value,
* the [onValue] callback will be called with that value.
* If this future is already completed, the callback will not be called
* immediately, but will be scheduled in a later microtask.

3、catchError是then函数里抛出异常后会被执行

async和await

任何一个函数都可以加上async关键字，它会将函数的返回值自动转换成Future类型，await关键字只能用于返回值为Future类型的函数前面，如下代码：

String _data = "";
int clickCount = 0;
Future _buttonClick() async {
  var data = _data + "Started $clickCount: ${DateTime.now().toString()}";
  print("开始啦");
  await Future.delayed(new Duration(seconds: 2));
  data += " End $clickCount: ${DateTime.now().toString()} ";
  clickCount += 1;
  _data = data;
  print("结束啦 $_data");
}

// ignore: non_constant_identifier_names
void function_main() async
{
  for (int i=0;i<5;i++) {
    _buttonClick();
  }
  print("最终值 $_data");
}

最终的输出结果为：
flutter: 开始啦
flutter: 开始啦
flutter: 开始啦
flutter: 开始啦
flutter: 开始啦
flutter: 最终值
flutter: 结束啦 Started 0: 2021-03-08 08:21:18.766893 End 0: 2021-03-08 08:21:20.772541
flutter: 结束啦 Started 0: 2021-03-08 08:21:18.769211 End 1: 2021-03-08 08:21:20.772872
flutter: 结束啦 Started 0: 2021-03-08 08:21:18.769887 End 2: 2021-03-08 08:21:20.773108
flutter: 结束啦 Started 0: 2021-03-08 08:21:18.770458 End 3: 2021-03-08 08:21:20.773354
flutter: 结束啦 Started 0: 2021-03-08 08:21:18.770836 End 4: 2021-03-08 08:21:20.773580
这里分析一下代码的执行顺序，function_main()函数中连续调用_buttonClick()五次，按照之前的分析await之前的语句顺序执行五次，等待2秒之后，await之后的语句再顺序执行五次，所以await之后的data变量的值固定为Started 0: 2021-03-08 08:21:18.766893，clickCount由于每次执行后会加1，所以它的值会变化。上面函数其实等价于如下：

Future _buttonClick() async {
  var data = _data + "Started $clickCount: ${DateTime.now().toString()}";
  print("开始啦");
  return Future.delayed(new Duration(seconds: 2)).then((value) {
    data += " End $clickCount: ${DateTime.now().toString()} ";
    clickCount += 1;
    _data = data;
    print("结束啦 $_data");
  });
}

创建新的isolate

当flutter应用启动时会创建一个默认的Root isolate(也可以理解为Main isolate)，根据官方的说法，如果在Root isolate中做大量的耗时任务有可能被系统wathdog强杀，所以对于一些耗时任务可以创建一个新的iso去完成，当做完任务后再通过Port和Main isolate进行通信，请看如下代码：

void function_main() async
{
  print("开始啦");
  var receivePort = new ReceivePort();
  var sp1 = receivePort.sendPort;
  var sp2 = receivePort.sendPort;
  print("值 ${sp1==sp2}");

  await Isolate.spawn(entryPoint, receivePort.sendPort);
  print("结束啦");
  // 两个isolate之间通过SendPort来进行通信
  SendPort sendPort = await receivePort.first;
  print("结束啦1");
  // Send a message to the Isolate
  sendPort.send("hello");
  print("结束啦2");
}
entryPoint(SendPort sendPort) async {
  // Open the ReceivePort to listen for incoming messages (optional)
  print("进来啦1");
  // 创建跟当前线程关联的ReceivePort对象，一个线程由
  var port = new ReceivePort();

  // Send messages to other Isolates
  sendPort.send(port.sendPort);
  print("进来啦2");

  // Listen for messages (optional)
  await for (var data in port) {
    print("data $data");
  }
  print("进来啦3");
}

打印结果：
flutter: 开始啦
flutter: 值 true
flutter: 结束啦
flutter: 进来啦1
flutter: 进来啦2
flutter: 结束啦1
flutter: 结束啦2
flutter: data hello

两个isolate之间基于Port实现的通信基于如下流程：