Flutter学习-Dart异步

1. Dart的异步模型

我们先来了解Dart是如何实现异步操作的

1.1 Dart是单线程

• 开发中的耗时操作： 比如网络请求、文件读取，如果我们的主线程一直等待这些操作完成，那么就会进行阻塞，无法响应其他时间，比如用户的点击
• 那么我们如何处理这些耗时操作？不同的语言有不同的处理方法？
  • 处理方式一：多线程，比如Java、C++，我们普遍的做法是开启一个新的线程（Threa）在新的线程中完成这些异步的操作，再通过线程间通信的方式，将拿到的数据传递给主线程。
  • 处理方式二： 单线程+事件循环，比如JavaScript、Dart都是基于单线程加事件循环来完成耗时操作的处理。不过单线程如何能进行耗时的操作呢？

单线程的异步操作，我之前也很不理解，表示对异步单线程操作充满疑惑？其实他们并不冲突。

• 因为我么的应用程序大部分时间都处于空闲状态，并不是无限制的在和用户进行交互
• 比如等待用户点击、网络请求数据的返回、文件读写的IO操作，这些等待的行为并不会阻塞我们的线程
• 这是因为类似于网络请求、文件读写的IO，我们都可以基于非阻塞调用

阻塞式调用和非阻塞式调用，如果想弄懂这点，我们需要知道操作系统中的阻塞式调用和非阻塞式调用的概念

• 阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态。
• 阻塞式调用： 调用结果返回之前，当前线程会被挂起，调用线程只有在得到调用结果之后才会继续执行。
• 非阻塞式调用： 调用执行之后，当前线程不会停止执行，只需要过一段时间来检查一下有没有结果返回即可

而我们开发中有很多耗时操作，都可以给予这样的非阻塞式调用

• 比如网络请求本身使用了Socket通信，而Socket本身提供了select模型，可以进行非阻塞方式的工作
• 比如文件读写的IO操作，我们可以使用操作系统提供的基于事件的回调机制

这些操作都不会阻塞我们单线程的执行，我们等待的过程中可以去做别的事情，等到真正的响应时，在去做真正的处理。那么这里就有两个问题？

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

1.2 Dart时间循环

1.2.1 什么是事件循环

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

事件循环是什么？

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

事件队列循环的伪代码：

// 这里我使用数组模拟队列, 先进先出的原则
List eventQueue = []; 
var event;

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

当我们有一些事件时，比如点击事件、IO事件、网络事件时，它们就会被加入到eventLoop中，当发现事件队列不为空时发现，就会取出事件，并且执行。

1.2.2 事件循环代码模拟

这里我们来看一段伪代码，理解点击事件和网络请求的事件是如何被执行的：

• 一个按钮RaisedButton，当发生点击时执行onPressed函数。
• onPressed函数中，我们发送了一个网络请求，请求成功后会执行then中的回调函数。

RaisedButton(
  child: Text('Click me'),
  onPressed: () {
    final myFuture = http.get('https://example.com');
    myFuture.then((response) {
      if (response.statusCode == 200) {
        print('Success!');
      }
    });
  },
)

这些事件是如何放在事件循环中执行的？

1. 当用户发生点击的时候，onPressed回调函数被放入事件循环中执行，执行的过程中发送了一个网络请求。
2. 网络请求发出去后，该事件循环不会被阻塞，而是发现要执行的onPressed函数已经结束，会将它丢弃掉
3. 网络请求成功后，会执行then中传入的回调函数，这也是一个事件，该事件被放入到事件循环中执行，执行完毕后，事件循环将其丢弃

尽管onPressed和then中的回调有一些差异，但是它们对于事件循环来说，都是告诉它：我有一段代码需要执行，快点帮我完成

2. Dart的异步操作

Dart中的异步操作主要使用Future以及async、await。
如果你之前有过前端的ES6、ES7编程经验，那么完全可以将Future理解成Promise，async、await和ES7中基本一致。
但是如果没有前端开发经验，Future以及async、await如何理解呢？

我们这里通过让线程睡眠的方式，来模拟一个网络耗时操作

2.1 同步网络耗时操作

我们先来看一个例子：

• 这个案例中我使用getNetworkData方法来模拟一个网络操作
• 该网络请求需要3秒钟时间，之后返回数据

void dartTest() {
    print("main start");
    getNetworkData();
    print("main end");
  }

  //模拟网络耗时操作方法
  String getNetworkData() {
    //让当前线程睡眠3秒
    sleep(Duration(seconds: 3));
    print("耗时操作方法-----执行");
    return "hello flutter";
  }

运行结果：

由运行结果可知getNetworkData函数确实会阻塞主线程3秒，显然这段代码的执行效果不是我们想要的结果，因为耗时操作代码阻塞了线程，导致后面的代码都无法正常的运行

2.2 异步网络请求

我们需要对上面的代码进行改造，代码如下：

• 和上面代码唯一的区别就是我使用了Future对象来将耗时的操作放在了其中传入的函数中；

这里我们发现Future其实是一个抽象类，我们之前说过，如果是抽象类创建对象是通过工厂方法来创建的，源码如下：

factory Future(FutureOr<T> computation()) {
    _Future<T> result = new _Future<T>();
    Timer.run(() {
      try {
        result._complete(computation());
      } catch (e, s) {
        _completeWithErrorCallback(result, e, s);
      }
    });
    return result;
  }

该方法有一个参数，是传递一个函数，有返回值，但是没有参数，FutureOr<T> : 表示是一个联合类型，是既可以返回一个Future对象，也可以返回一个具体对象

下面代码是直接返回一个字符串对象

示例代码：

void dartTest() {
    print("main start");
    getNetworkData();
    print("main end");
  }

  //模拟网络耗时操作方法
  Future<String> getNetworkData() {
    return Future((){
      //让当前线程睡眠3秒
      sleep(Duration(seconds: 3));
      print("耗时操作方法-----执行");
      return "hello flutter";
    });
  }

运行结果：

比较两次代码运行结果：

• 这一次代码按照顺序执行，并没有任何的阻塞现象
• 将一个耗时操作隔离起来，这个操作不会再影响我们主线程执行了

这里就产生了一个问题，我们如何拿到异步操作最终返回的结果

其实Dart这里给Future给提供了一个叫then的函数，可以通过then来回调结果

then函数：

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

示例代码：

void dartTest() {
    print("main start");
    var furute = getNetworkData();
    furute.then((value) {
      print("耗时操作的结果--========$value");
    });

    print("main end");
  }

• 注意：
  • 如果返回的Future对象没有指定任何的类型，那么then回调函数中的参数类型是dynamic
  • 当future实例有返回结果时，会自动回调then中传入的函数，该函数会被放入到事件循环中，被执行
  • then后面的回调函数是在Future函数有结果之后，才执行回调函数
    运行结果：
    

2.3 异常情况（cathError）

大家都知道很多时候，网络请求、IO这些耗时操作可能会出现异常情况，那么我们如何获取到异常信息

Dart中给我们提供了cathError方法来捕获异常

示例代码：

  void dartTest() {
    print("main start");
    var furute = getNetworkData();
    furute.then((value) {
      print("耗时操作的结果--========$value");
    }).catchError((errorMsg){
      print("打印异常信息========$errorMsg");
    });

    print("main end");
  }

  //模拟网络耗时操作方法
  Future<String> getNetworkData() {
    return Future((){
      //让当前线程睡眠3秒
      sleep(Duration(seconds: 3));
      print("耗时操作方法-----执行");
      //return "hello flutter";
      //这里我们不返回结果了，直接抛出一个异常
      throw Exception("耗时操作出现异常了=====");
    });
  }

运行结果：

如果耗时操作出现异常没有返回运行结果的时候，我们可以通过catchError函数来捕获异常

有的人可能会想回调方法和捕获异常的方法可不可以这样分开调用

void dartTest() {
    print("main start");
    var furute = getNetworkData();
    furute.then((value) {
      print("耗时操作的结果--========$value");
    });
    furute.catchError((errorMsg){
      print("打印异常信息========$errorMsg");
    });

    print("main end");
  }

运行结果

这种写法我们可以发现我们并没有捕获异常，程序出现crash，为什么这样不可以了

捕获异常不能这样分开写， 因为then函数返回一个future对象，直接链式调用使用的then方法返回的future对象，和调用then方法的future对象不是同一个对象了

但是如果是分开调用， 当then方法已近执行完成之后， 在使用future调用对象，可能当前对象future在then方法中发生了什么改变， 导致捕获异常的方法出现问题，捕获不了异常

但是如果不调用then方法，直接调用捕获异常的方法 也是可以正常捕获异常的

如果你非要分开写，你可以这样写：

 void dartTest() {
    print("main start");
    var furute = getNetworkData();
    var catchFuture = furute.then((value) {
      print("耗时操作的结果--========$value");
    });
    catchFuture.catchError((errorMsg){
      print("打印异常信息========$errorMsg");
    });

    print("main end");
  }

2.4 案例小结

我们通过一个案例来学习了一些Future的使用过程：

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

2.5 whenComplete 函数

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

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

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

状态二：完成状态（completed）

• 当Future内部的操作执行完成，通常会返回一个值，或者抛出一个异常。
• 这两种情况，我们都称Future为完成状态。

void dartTest() {
    print("main start");

    var future = getNetworkData();
    future.then((value) {
      print("耗时操作返回结果====$value");
    }).catchError((errorMsg){
      print("出现异常===$errorMsg");
    }).whenComplete(() {
      print("耗时操作代码执行完成了");
    });

    print("main END");
  }

  Future<String> getNetworkData() {
    return Future((){
      sleep(Duration(seconds: 3));
      print("耗时操作执行===========");
      //return "hello flutter";
      throw Exception("****出现异常了****");
    });
  }

不管是程序正常执行，还是执行过程中出现异常， 最终都会执行whenComplete中的代码块， 相当于Java的try catch中的final

2.6 flutter中的链式调用

针对于上面代码我们可以进行如下改进:

void dartTest() {
    print("main start");
    Future(() {
      sleep(Duration(seconds: 3));
      print("耗时操作执行===========");
      return "hello flutter";
      //throw Exception("****出现异常了****");
    }).then((value) {
      print("耗时操作返回结果====$value");
    }).catchError((errorMsg) {
      print("出现异常===$errorMsg");
    }).whenComplete(() {
      print("耗时操作代码执行完成了");
    });

    print("main END");
  }

需求： 需要进行三次网络请求， 第一次网络请求回来的结果，作为第二次网络请求的参数， 第二次网络请求的结果作为第三次网络请求的参数

可能有很多人想的解决是在第一次的回到函数（then）中在创建一个future对象，进行第二次网络请求，然后再第二次的回调函数中，在创建一个Future进行第三次网络请求。
伪代码：

Future(() {
   //第一次网路请求
}).then((value) {
   //第一次网络请求回调
   Future(() {
   //第二次网路请求
	}).then((value) {
   		//第二次网路请求回调
   			Future(() {
   			//第三次网路请求
			}).then((value) {
   				//第三次网路请求回调
			})
	})
})

Dart语法中提供链式调用来解决这种问题：

void dartTest() {
    print("main start");
    Future(() {
      //第一次网路请求
      sleep(Duration(seconds: 3));
      return "first result";
      //throw Exception("****出现异常了****");
    }).then((value) {
      //第二次网络请求
      sleep(Duration(seconds: 2));
      print("第一次请求的结果====$value");
      return "second result";
    }).then((value) {
      //第三次网络请求
      sleep(Duration(seconds: 1));
      print("第二次请求的结果======$value");
      return "third result";
    }).then((value) {
      print("获取第三次的最终返回结果======$value");
    });

    print("main END");
  }

注意：如果其中一次网络请求发生异常，那么会直接调用catchError的回调函数，然后后面的then是不会执行的

2.7 Future其它相关API

2.7.1 Future.value(value)

直接获取一个完成的Future，该Future会直接调用then的回调函数

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

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

  print("main function end");
}

疑惑：为什么立即执行，但是哈哈哈是在最后打印的呢？

• 这是因为Future中的then会作为新的任务会加入到事件队列中（Event Queue），加入之后你肯定需要排队执行了

2.7.2 Future.error(object)

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

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

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

  print("main function end");
}
	

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

延时函数也是可以链式调用的：

Future<String>.delayed(Duration(seconds: 3), () {
    return "Hello Flutter";
  }).then((res) {
    print(res);
    return "Hello World";
  }).then((res) {
    print(res);
  });

3. await、async

3.1 概念理解

如果你已经完全搞懂了Future，那么学习await、async应该没有什么难度。
await、async是什么呢？

• 它们可以让我们用同步的代码格式，去实现异步的调用过程。
• 并且，通常一个async的函数会返回一个Future
  我们已经知道，Future可以做到不阻塞我们的线程，让线程继续执行，并且在完成某个操作时改变自己的状态，并且回调then或者catchError回调。

如何生成一个Fliutter?

• 通过我们前面学习的Future构造函数，或者后面学习的Future其他API都可以。
• 还有一种就是通过async的函数。

3.2 案例代码演练

我们来对之前的Future异步处理代码进行改造，改成await、async的形式。

void dartTest() {
    print("main start");

    var result = getNetworkData().then((res) {
      print(res);
    });
    print(result);

    print("main end");
  }

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

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

• 注意：
  • await必须要在async函数中才能使用
  • 使用async标记的函数，必须返回一个Future对象
  • await并不是阻塞等待，而是异步等待
  • 我们现在可以像同步代码一样去使用Future异步返回的结果
  • 等待拿到结果之后和其他数据进行拼接，然后一起返回
  • 返回的时候并不需要包装一个Future，直接返回即可，但是返回值会默认被包装在一个Future中；

比如我们上面三次网络请求的那个案例可以使用await和async进行如下改造

import 'dart:io';

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

  getData().then((res) {

  }).catchError((err) {
    
  });

  print("main end");
}
Future getData() async {
  // 1.调用第一次网络请求
  // getNetworkData("argument1").then((res) {
  //   print(res);
  //   return getNetworkData(res);
  // }).then((res) {
  //   print(res);
  //   return getNetworkData(res);
  // }).then((res) {
  //   print(res);
  // });

  var res1 = await getNetworkData("argument1"); //表示等这个语句的结果执行完成之后，才继续往下执行
  print(res1);
  var res2 = await getNetworkData(res1);
  print(res2);
  var res3 = await getNetworkData(res2);
  
  return res3;
}

Future getNetworkData(String arg) {
  return Future(() {
    sleep(Duration(seconds: 3));
    return "Hello World" + arg;
  });
}

4. Dart的异步补充

4.1 任务执行顺序

4.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）中的所有任务；

4.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"));

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

4.2 多核CPU的利用

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

4.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;
}

• **注意：compute传入的函数必须是一个全局的函数，如果不是全局函数则会报错，因为是放在另外一个Isolate中运行的， 如果是一个对象方法， 那没有对象就意味着执行不了方法，所以要求必须全局函数 **