三. Dart的异步补充

3.1. 任务执行顺序

3.1.1. 认识微任务队列

在前面学习学习中，我们知道Dart中有一个事件循环（Event Loop）来执行我们的代码，里面存在一个事件队列（Event Queue），事件循环不断从事件队列中取出事件执行。

但是如果我们严格来划分的话，在Dart中还存在另一个队列：微任务队列（Microtask Queue）。

• 微任务队列的优先级要高于事件队列；
  
• 也就是说事件循环都是优先执行微任务队列中的任务，再执行 事件队列 中的任务；
  

那么在Flutter开发中，哪些是放在事件队列，哪些是放在微任务队列呢？

• 所有的外部事件任务都在事件队列中，如IO、计时器、点击、以及绘制事件等；
  
• 而微任务通常来源于Dart内部，并且微任务非常少。这是因为如果微任务非常多，就会造成事件队列排不上队，会阻塞任务队列的执行（比如用户点击没有反应的情况）；
  

说道这里，你可能已经有点凌乱了，在Dart的单线程中，代码到底是怎样执行的呢？

• 1、Dart的入口是main函数，所以main函数中的代码会优先执行；
  
• 2、main函数执行完后，会启动一个事件循环（Event Loop）就会启动，启动后开始执行队列中的任务；
  
• 3、首先，会按照先进先出的顺序，执行 微任务队列（Microtask Queue）中的所有任务；
  
• 4、其次，会按照先进先出的顺序，执行 事件队列（Event Queue）中的所有任务；
  

                                    代码执行顺序

3.1.2. 如何创建微任务

在开发中，我们可以通过dart中async下的scheduleMicrotask来创建一个微任务：

import "dart:async";
main(List<String> args) {
  scheduleMicrotask(() {
    print("Hello Microtask");
  });
}

在开发中，如果我们有一个任务不希望它放在Event Queue中依次排队，那么就可以创建一个微任务了。

Future的代码是加入到事件队列还是微任务队列呢？

Future中通常有两个函数执行体：

• Future构造函数传入的函数体
  
• then的函数体（catchError等同看待）
  

那么它们是加入到什么队列中的呢？

• Future构造函数传入的函数体放在事件队列中
  
• then的函数体要分成三种情况：
  
• 情况一：Future没有执行完成（有任务需要执行），那么then会直接被添加到Future的函数执行体后；
  
• 情况二：如果Future执行完后就then，该then的函数体被放到如微任务队列，当前Future执行完后执行微任务队列；
  
• 情况三：如果Future是链式调用，意味着then未执行完，下一个then不会执行；
  

// future_1加入到eventqueue中，紧随其后then_1被加入到eventqueue中
Future(() => print("future_1")).then((_) => print("then_1"));
// Future没有函数执行体，then_2被加入到microtaskqueue中
Future(() => null).then((_) => print("then_2"));
// future_3、then_3_a、then_3_b依次加入到eventqueue中
Future(() => print("future_3")).then((_) => print("then_3_a")).then((_) => print("then_3_b"));

3.1.3. 代码执行顺序

我们根据前面的规则来学习一个终极的代码执行顺序案例：

import "dart:async";
main(List<String> args) {
  print("main start");
  Future(() => print("task1"));
  final future = Future(() => null);
  Future(() => print("task2")).then((_) {
    print("task3");
    scheduleMicrotask(() => print('task4'));
  }).then((_) => print("task5"));
  future.then((_) => print("task6"));
  scheduleMicrotask(() => print('task7'));
  Future(() => print('task8'))
    .then((_) => Future(() => print('task9')))
    .then((_) => print('task10'));
  print("main end");
}

代码执行的结果是：

main start
main end
task7
task1
task6
task2
task3
task5
task4
task8
task9
task10

代码分析：

• 1、main函数先执行，所以main start和main end先执行，没有任何问题；
  
• 2、main函数执行过程中，会将一些任务分别加入到EventQueue和MicrotaskQueue中；
  
• 3、task7通过scheduleMicrotask函数调用，所以它被最早加入到MicrotaskQueue，会被先执行；
  
• 4、然后开始执行EventQueue，task1被添加到EventQueue中被执行；
  
• 5、通过final future = Future(() => null);创建的future的then被添加到微任务中，微任务直接被优先执行，所以会执行task6；
  
• 6、一次在EventQueue中添加task2、task3、task5被执行；
  
• 7、task3的打印执行完后，调用scheduleMicrotask，那么在执行完这次的EventQueue后会执行，所以在task5后执行task4（注意：scheduleMicrotask的调用是作为task3的一部分代码，所以task4是要在task5之后执行的）
  
• 8、task8、task9、task10一次添加到EventQueue被执行；
  

事实上，上面的代码执行顺序有可能出现在面试中，我们开发中通常不会出现这种复杂的嵌套，并且需要完全搞清楚它的执行顺序；

但是，了解上面的代码执行顺序，会让你对EventQueue和microtaskQueue有更加深刻的理解。

3.2. 多核CPU的利用

3.2.1. Isolate的理解

在Dart中，有一个Isolate的概念，它是什么呢？

• 我们已经知道Dart是单线程的，这个线程有自己可以访问的内存空间以及需要运行的事件循环；
  
• 我们可以将这个空间系统称之为是一个Isolate；
  
• 比如Flutter中就有一个Root Isolate，负责运行Flutter的代码，比如UI渲染、用户交互等等；
  

在 Isolate 中，资源隔离做得非常好，每个 Isolate 都有自己的 Event Loop 与 Queue，

• Isolate 之间不共享任何资源，只能依靠消息机制通信，因此也就没有资源抢占问题。
  

但是，如果只有一个Isolate，那么意味着我们只能永远利用一个线程，这对于多核CPU来说，是一种资源的浪费。

如果在开发中，我们有非常多耗时的计算，完全可以自己创建Isolate，在独立的Isolate中完成想要的计算操作。

如何创建Isolate呢？

创建Isolate是比较简单的，我们通过Isolate.spawn就可以创建了：

import "dart:isolate";
main(List<String> args) {
  Isolate.spawn(foo, "Hello Isolate");
}
void foo(info) {
  print("新的isolate：$info");
}

3.2.2. Isolate通信机制

但是在真实开发中，我们不会只是简单的开启一个新的Isolate，而不关心它的运行结果：

• 我们需要新的Isolate进行计算，并且将计算结果告知Main Isolate（也就是默认开启的Isolate）；
  
• Isolate 通过发送管道（SendPort）实现消息通信机制；
  
• 我们可以在启动并发Isolate时将Main Isolate的发送管道作为参数传递给它；
  
• 并发在执行完毕时，可以利用这个管道给Main Isolate发送消息；
  

import "dart:isolate";
main(List<String> args) async {
  // 1.创建管道
  ReceivePort receivePort= ReceivePort();
  // 2.创建新的Isolate
  Isolate isolate = await Isolate.spawn<SendPort>(foo, receivePort.sendPort);
  // 3.监听管道消息
  receivePort.listen((data) {
    print('Data：$data');
    // 不再使用时，我们会关闭管道
    receivePort.close();
    // 需要将isolate杀死
    isolate?.kill(priority: Isolate.immediate);
  });
}
void foo(SendPort sendPort) {
  sendPort.send("Hello World");
}

但是我们上面的通信变成了单向通信，如果需要双向通信呢？

• 事实上双向通信的代码会比较麻烦；
  
• Flutter提供了支持并发计算的compute函数，它内部封装了Isolate的创建和双向通信；
  
• 利用它我们可以充分利用多核心CPU，并且使用起来也非常简单；
  

注意：下面的代码不是dart的API，而是Flutter的API，所以只有在Flutter项目中才能运行

main(List<String> args) async {
  int result = await compute(powerNum, 5);
  print(result);
}
int powerNum(int num) {
  return num * num;
}