Dart值得注意的知识点(三)

2020-04-12 本文已影响0人 WinJayQ

1.Dart的异步模型

1.1 Dart是单线程的

开发中的耗时操作：

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

如何处理耗时的操作呢？

针对如何处理耗时的操作，不同的语言有不同的处理方式。
* 处理方式一： 多线程，比如Java、C++，我们普遍的做法是开启一个新的线程（Thread），在新的线程中完成这些异步的操作，再通过线程间通信的方式，将拿到的数据传递给主线程。
* 处理方式二： 单线程+事件循环，比如JavaScript、Dart都是基于单线程加事件循环来完成耗时操作的处理。不过单线程如何能进行耗时的操作呢？！

1.2 Dart事件循环

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

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

2.Dart的异步操作

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

import "dart:io";

main(List<String> args) {
  print("main function start");
  var future = getNetworkData();
  future.then((value) {
    print(value);
  }).catchError((error) {
    // 捕获出现异常时的情况
    print(error);
  });
  print(future);
  print("main function end");
}

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

2.1 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";
  });
}

2.2 案例代码

await关键字必须存在于async函数中
使用async标记的函数，必须返回一个Future对象

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

  return "请求到的数据：" + result;
}

我们现在可以像同步代码一样去使用Future异步返回的结果；
等待拿到结果之后和其他数据进行拼接，然后一起返回；
返回的时候并不需要包装一个Future，直接返回即可，但是返回值会默认被包装在一个Future中；

3.微任务队列

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

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

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

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

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

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

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

image.png

3.5 如何创建微任务

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


import "dart:async";

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

3.6 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.7 代码执行顺序案例

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

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有更加深刻的理解。

学习内容来自Flutter从入门到实战