八、Dart的异步

2020-11-19 本文已影响0人爱玩游戏的iOS菜鸟

一、Dart的异步模型

1.1 程序中的耗时操作

开发中的耗时操作：

在开发中，经常会遇到一些耗时的操作，比如网络请求、文件读取、数据处理等等；
如果我们的主线程一直在等待这些耗时的操作完成，那么就会进行阻塞，无法响应其它事件，比如用户的点击；

如何处理耗时的操作呢？针对如何处理耗时的操作，不同的语言有不同的处理方式

处理方式一： 多线程，比如Java、C++，开启一个新的线程(Thread)，在新的线程中完成这些异步的操作，再通过线程间通信的方式，将拿到的数据传递给主线程。
处理方式二： 单线程+事件循环，比如JavaScript、Dart都是基于单线程 + 事件循环(Event Loop)来完成耗时操作的处理。

不过单线程如何能进行耗时的操作呢？！我们就需要先了解一下操作系统中的阻塞式调用和非阻塞式调用的概念

1.2 阻塞式调用和非阻塞式调用

阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态。

阻塞式调用： 调用结果返回之前，当前线程会被挂起，调用线程只有在得到调用结果之后才会继续执行。
非阻塞式调用： 调用执行之后，当前线程不会停止执行，只需要过一段时间来检查一下有没有结果返回即可。

这时，既然单线程处理耗时操作是通过非阻塞式调用，那有两个问题：

问题一： 单线程是如何来处理网络通信、IO操作它们返回的结果呢？
问题二： 如果在多核CPU中，单线程是不是就没有充分利用CPU呢？

1.3 Dart是单线程

在了解了上面的概念之后，我们就可以开始学习Dart的是如何处理耗时操作了。

Dart就是通过单线程+事件循环(Event Loop)的方式来完成耗时操作的处理

1.3.1 事件循环 (Event Loop)

单线程模型中主要就是在维护着一个事件循环(Event Loop)。

事件循环是什么呢？

事件循环很简单，就是将需要处理的一系列事件（包括点击事件、IO事件、网络事件）放在一个事件队列（Event Queue）中。
不断的从事件队列（Event Queue）中取出事件，并执行其对应需要执行的代码块，直到事件队列清空位置。

下面通过伪代码来理解事件循环的逻辑：

//使用数组模拟队列, 先进先出的原则
List eventQueue = []; //这个数组会不间断的添加事件
var event;

// 事件循环从启动的一刻，永远在执行
while (true) {
  if (eventQueue.length > 0) {
    // 取出一个事件
    event = eventQueue.removeAt(0);
    // 执行该事件
    event();
  }
}

和iOS RunLoop有点相似

二、Dart的异步操作

Dart中的异步操作主要使用Future以及async、await。

2.1 Future

2.1.1 同步的网络请求

我们先做一个模拟网络请求的事例

import "dart:io";

main(List<String> args) {
  print("main function start");
  print(getNetworkData());
  print("main function end");
}

String getNetworkData() {
  sleep(Duration(seconds: 3));
  return "network data";
}

返回结果:

main function start
//3秒之后
network data
main function end

很明显，getNetworkData()阻塞main()函数的执行。显然，不是我们希望的结果。

2.1.2 异步的网络请求

我们通过Future对象对上面的代码略微改进

import "dart:io";

main(List<String> args) {
  print("main function start");
  print(getNetworkData());
  print("main function end");
}

Future<String> getNetworkData() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
    return "network data";
  });
}

得到请求结果：

main function start
Instance of 'Future<String>'
main function end
///
[Done] exited with code=0 in 3.256 seconds

打印结果出现了Future实例对象(后续我们再学习)，并且没有阻塞主线程。但是我们如何拿到我们需要的结果呢？

获取Future得到的结果：通过.then的回调获取返回结果，通过.catchError捕获异常

import "dart:io";

main(List<String> args) {
  print("main function start");
  var future = getNetworkData();
  future.then((value) {
    print(value);
  }).catchError((error) {
    print(error);
  });
  print("main function end");
}

Future<String> getNetworkData() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
    //return "network data";
    //不返回正常结果 抛出异常
    throw Exception("网络请求出现错误");
  });
}

得到请求结果：

main function start
main function end
Exception: 网络请求出现错误

[Done] exited with code=0 in 3.252 seconds

2.1.3 Future的使用

通过上面的代码我们可以大致了解Future的使用流程

1、创建一个Future(可能是我们创建的，也可能是调用内部API或者第三方API获取到的一个Future，总之你需要获取到一个Future实例，Future通常会对一些异步的操作进行封装)；
2、通过.then(成功回调函数)的方式来监听Future内部执行完成时获取到的结果；
3、通过.catchError(失败或异常回调函数)的方式来监听Future内部执行失败或者出现异常时的错误信息；

main(List<String> args) {
print("main function start");
var future = getNetworkData();
future.then((value) {
 print(value);
});
//必须链式调用 不可以分开写
future.catchError((error) {
 // 捕获出现异常时的情况
 print(error);
});
print(future);
print("main function end");
}

不可以这样写,在调用.then之后返回的并不是最初的future(查看底层源码介绍)

Future<R> then<R>(FutureOr<R> onValue(T value), {Function? onError});

2.1.4 Future的链式调用

我们可以在then中继续返回值，会在下一个链式的then调用回调函数中拿到返回的结果

import "dart:io";

main(List<String> args) {
  print("main function start");

  getNetworkData().then((value1) {
    print(value1);
    return "content data2";
  }).then((value2) {
    print(value2);
    return "message data3";
  }).then((value3) {
    print(value3);
  });

  print("main function end");
}

Future<String> getNetworkData() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
    // 不再返回结果，而是出现异常
     return "network data1";
  });
}

返回结果：

main function start
main function end
//3秒后 同时出现
network data1
content data2
message data3

2.1.5 Future的其他API

Future.value(value) 获取一个完成的Future，直接调用then的回调函数

main(List<String> args) {
  print("main function start");

  Future.value("哈哈哈").then((value) {
    print(value);
  });

  getNetworkData().then((value) {
    print(value);
  });
  sleep(Duration(seconds: 1));
  print("main function end");
}

Future<String> getNetworkData() {
  return Future<String>(() {
    sleep(Duration(seconds: 1));
    // 不再返回结果，而是出现异常
    return "network data1";
  });
}

//打印结果
main function start
//1秒后
main function end
哈哈哈
//1秒后
network data1

Future中的then会作为新的任务会加入到事件队列中（Event Queue）即使是立即执行，也会晚于main函数

Future.error(object) 获取一个完成的Future，但是是一个发生异常的Future，会直接调用catchError的回调函数

main(List<String> args) {
  print("main function start");

  Future.error(Exception("错误信息")).catchError((error){
    print(error);
  });

  print("main function end");
}
//打印结果
main function start
main function end
Exception: 错误信息

这里需要补充：Future的两种状态

事实上Future在执行的整个过程中，我们通常把它划分成了两种状态：

状态一：未完成状态（uncompleted）

执行Future内部的操作时(在前面的案例中就是具体的网络请求过程，我们使用了延迟来模拟)，我们称这个过程为未完成状态

状态二：完成状态（completed）

当Future内部的操作执行完成，通常会返回一个值，或者抛出一个异常。

这两种情况，都称Future为完成状态。

Future.delayed(时间, 回调函数) 在延迟一定时间时执行回调函数，执行完回调函数后会执行then的回调；

main(List<String> args) {
  print("main function start");

  Future.delayed(Duration(seconds: 3), () {
    return "3秒后的信息";
  }).then((value) {
    print(value);
  });

  print("main function end");
}

2.2 async、await

2.2.1. 理论概念理解

await、async是什么呢？

Dart中的关键字
可以用同步的代码格式，去实现异步的调用过程。
通常一个async修饰的函数会返回一个Future

2.2.2. 案例代码演练

Talk is cheap. Show me the code.

import "dart:io";

main(List<String> args) {
  print("main function start");
  getNetworkData().then((value) {
    print(value);
  }).whenComplete(() {
    print("请求完成咯！");
  }).catchError((error) {
    print("请求报错咯！$error");
  });

  print("main function end");
}

Future<String> getNetworkData() async {
  var result = await Future.delayed(Duration(seconds: 3), () {
    return "network data";
  });

  return result;
}

请求结果：

main function start
main function end
network data
请求完成咯！

三、Dart异步补充

3.1 任务执行顺序

3.1.1 认识微任务队列

Dart中有一个事件循环（Event Loop）来执行我们的代码，事件队列（Event Queue），事件循环不断从事件队列中取出事件执行。

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

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

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

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

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

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

3.1.2. 如何创建微任务

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

import "dart:async";

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

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

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

Future构造函数传入的函数体
then的函数体(catchError等同看待)

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

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

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，会被先执行；(MicrotaskQueue执行完后没有了)
4、然后开始执行EventQueue，task1被添加到EventQueue中被执行；
5、通过final future = Future(() => null);创建的future的then被添加到MicrotaskQueue中，所以会执行task6；(MicrotaskQueue执行完后又没有了)
6、一次在EventQueue中添加task2、task3、task5被执行；（4在5的后面）
7、task3的打印执行完后，调用scheduleMicrotask，那么在执行完这次的EventQueue后会执行，所以在task5后执行task4（注意：scheduleMicrotask的调用是作为task3的一部分代码，所以task4是要在task5之后执行的）
8、task8、task9、task10一次添加到EventQueue被执行；

总结规律：scheduleMicrotask就好比可以随时插队的一个组，main执行完后优先执行scheduleMicrotask，然后执行EventQueue，一旦有新的任务加入到scheduleMicrotask遍优先执行

四、Isolate通信机制

下面就是我们回答上面的问题：Dart的单线程机制，是否会在多核CPU中，没有充分利用CPU呢？

在日常的开发中，单线程 + 事件循环已经可以解决绝大多数问题。

如果必须要用到多核CPU处理的时候，就要用到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，并且使用起来也非常简单

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

int powerNum(int num) {
  return num * num;
}

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