Javascript is required
Flutter-异步
Flutter

Dart是单线程的

开发中的耗时操作：

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

如何处理耗时的操作呢？

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

场景

我们的一个应用程序大部分时间都是处于空闲的状态的，并不是无限制的在和用户进行交互。

  • 比如等待用户点击、网络请求数据的返回、文件读写的IO操作，这些等待的行为并不会阻塞我们的线程；
  • 这是因为类似于网络请求、文件读写的IO，我们都可以基于非阻塞调用；

如何搞定异步操作的？

单线程是如何来处理网络通信，IO操作他们返回的结果呢？

单线程+事件循环

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

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

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

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

Dart事件循环

什么是事件循环

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

事件循环是什么呢？

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

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

例子

点击发送网络请求

RaisedButton(
    child: Text('Get Data'),
  onPressed:(){
    final req = http.get('http://www.xxx.com')
      .then(res=>{
        // 获取到数据
      })
  }
)

当用户发生点击的时候，onPressed回调函数被放入事件循环中执行，执行的过程中发送了一个网络请求。

网络请求发出去后，该事件循环不会被阻塞，而是发现要执行的onPressed函数已经结束，会将它丢弃掉。

网络请求成功后，会执行then中传入的回调函数，这也是一个事件，该事件被放入到事件循环中执行，执行完毕后，事件循环将其丢弃。

Dart Future

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

如果你之前有过前端的ES6、ES7编程经验，那么完全可以将Future理解成Promise，async、await和ES7中基本一致。

Future

异步的网络请求

import 'dart:io';

void main(){
  print("Main start");
  getNetwork();
  print("Main end");
}

/// 有异步的方法
getNetwork(){
  print("开始请求网络数据");
  Future((){
    sleep(Duration(seconds: 3));
    print('Get Network Data');
  });
}

获取Future得到的结果

有了Future之后，如何去获取请求到的结果：通过.then的回调

var future = getNetworkData();

// 当future实例有返回结果时，会自动回调then中传入的函数
// 该函数会被放入到事件循环中，被执行
future.then((value) {
  print(value);
});

获取异常结果

如果调用过程中出现了异常，拿不到结果，如何获取到异常的信息呢？

....
var future = getNetworkData();
future.then((value) {
  print(value);
}).catchError((error) { // 捕获出现异常时的情况
  print(error);
});
....

步骤

  1. 创建一个Future
  2. 通过.then(成功回调函数)的方式来监听Future内部执行完成时获取到的结果
  3. 通过.catchError(失败或异常回调函数)的方式来监听Future内部执行失败或者出现异常时的错误信息

Future的两种状态

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

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

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

状态二：完成状态（completed）

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

image-20201220235142395

Future 链式调用

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

Future其他API

Future.value(value)

/// 例子
void main(){
  print("main start");
  Future.value("Taoya").then((val){
    print(val);
  });
  print("main end");
}
// 输出
main start
main end
Taoya

Future.error(object) 

/// 例子
void main(){
  print("main start");
  Future.error(
    Exception("错误信息")
  ).catchError((error){
    print(error);
  });
  print("main end");
}
// 输出
main start
main end
Exception: 错误信息

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


// 例子
void main(){
  print("main start");
  Future.delayed(Duration(seconds: 3)).then((value) => {
    print('执行')
  });
  print("main end");
}
// 输出
main start
main end
执行

Dart await, async

await、async是什么呢？

它们是Dart中的关键字

它们可以让我们用同步的代码格式，去实现异步的调用过程

并且，通常一个async的函数会返回一个Future

我们已经知道，Future可以做到不阻塞我们的线程，让线程继续执行，并且在完成某个操作时改变自己的状态，并且回调then或者errorCatch回调。

如何生成一个Future呢？

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

格式

返回值 函数名称() async {
  return await Future((){
    // Do Something
  });
}

补充

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

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

image-20201221002319410

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

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

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

在Dart的单线程中，代码到底是怎样执行的呢？

1、Dart的入口是main函数，所以main函数中的代码会优先执行；

2、main函数执行完后，会启动一个事件循环（Event Loop）就会启动，启动后开始执行队列中的任务；

3、首先，会按照先进先出的顺序，执行 微任务队列（Microtask Queue）中的所有任务；

4、其次，会按照先进先出的顺序，执行 事件队列（Event Queue）中的所有任务；

image-20201220230520818

如何创建微任务

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

import "dart:async";

main() {
  // 声明
  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"));

多核CPU的利用

image-20201221002039364

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

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