Flutter中Dart异步模型

原创

jerrypxiao

修改于 2019-11-13 22:52:24

1.9K0

修改于 2019-11-13 22:52:24

文章被收录于专栏：音视频专栏

前言

我们知道Flutter 框架有出色的渲染和交互能力。支撑起这些复杂的能力背后，实际上是基于单线程模型的 Dart。那么，与原生 Android 和 iOS 的多线程机制相比，单线程的 Dart 如何从语言设计层面和代码运行机制上保证 Flutter UI 的流畅性呢？

我们从下面几个方面阐述一下：

Dart 语言单线程模型和 Event Loop 处理机制
异步处理和并发编程的原理和使用方法
Dart 单线程模型下的代码运行本质

1. Dart单线程模型

dart是单线程运行的。怎么理解这句话呢, 从下面几个方面可以看到这个设计思想.

1.1 默认单一运行的线程

dart默认运行在Main函数存在线程，在dart中称之为isolate，这个线程我们可称之为main isolate。单线程任务处理的，如果不开启新的isolate，任务默认在主isolate中处理。一旦 Dart 函数执行，它将按照在 main 函数出现的次序一个接一个地持续执行，直到退出。换而言之，Dart 函数在执行期间，无法被其他 Dart 代码打断。

1.2 独享内存

Android和IOS可以自由的开辟除了UI主线程之外的线程，这些线程和主线程可以共享内存的变量，但是, Dart中的isolate无法共享内存。Isolate 不能共享内存，他们就像是单独的分离的 app，通过消息进行沟通。除了显式指定代码运行在别的 isolate 或者 worker 中，其他代码都运行在 app 的 main isolate 中。更多信息可以访问Use isolates or workers if necessary

1.3 质疑

（1）假如有一个任务（读写文件或者网络）耗时10秒，并且加入到了事件任务队列中，执行单这个任务的时候不就把线程卡主吗？

答：文件I/O和网络调用并不是在Dart层做的，而是由操作系统提供的异步线程，他俩把活儿干完之后把结果刚到队列中，Dart代码只是执行一个简单的读动作。

（2）单线程模型是指的事件队列模型，和绘制界面的线程是一个吗？

答：我们所说的单线程指的是主Isolate。而GPU绘制指令有单独的线程执行，跟主Isolate无关。事实上Flutter提供了4种task runner，有独立的线程去运行专属的任务：参见：深入理解Flutter引擎线程模式

Platform Task Runner：处理来自平台（Android/iOS）的消息
UI Task Runner：执行渲染逻辑、处理native plugin的消息、timer、microtask、异步I/O操作处理等
GPU Task Runner：执行GPU指令
IO Task Runner：执行I/O任务

2. Event Loop 机制

如图所示，dart也存在事件队列和事件循环。每个isolate也包含一个事件循环,区别是他有两个事件队列，event loop事件循环，以及event queue和microtask queue事件队列，event和microtask队列有点类似iOS的source0和source1。

event queue：负责处理I/O事件、绘制事件、手势事件、接收其他isolate消息等外部事件。
microtask queue：可以自己向isolate内部添加事件，事件的优先级比event queue高。

先检查MicroTask队列是否为空，非空则先执行MicroTask队列中的MicroTask
一个MicroTask执行完后，检查有没有下一个MicroTask，直到MicroTask队列为空，才去执行Event队列
在Evnet 队列取出一个事件处理完后，再次返回第一步，去检查MicroTask队列是否为空

我们可以看出，将任务加入到MicroTask中可以被尽快执行，但也需要注意，当事件循环在处理MicroTask队列时，会阻塞event队列的事件执行，这样就会导致渲染、手势响应等event事件响应延时。为了保证渲染和手势响应，应该尽量将耗时操作放在event队列中。

我们通常很少会直接用到微任务队列，就连 Flutter 内部，也只有 7 处用到了而已（比如，手势识别、文本输入、滚动视图、保存页面效果等需要高优执行任务的场景）。

简单总结为一二一模型：1个事件循环和2个队列的单线程执行模型。

3. 异步任务调度

为什么单线程也可以异步？这里有一个大前提，那就是我们的 App 绝大多数时间都在等待。比如，等用户点击、等网络请求返回、等文件 IO 结果，等等。而这些等待行为并不是阻塞的。比如说，网络请求，Socket 本身提供了 select 模型可以异步查询；而文件 IO，操作系统也提供了基于事件的回调机制。所以，基于这些特点，单线程模型可以在等待的过程中做别的事情，等真正需要响应结果了，再去做对应的处理。因为等待过程并不是阻塞的，所以给我们的感觉就像是同时在做多件事情一样。但其实始终只有一个线程在处理你的事情。

异步任务我们用的最多的还是优先级更低的 Event Queue。比如，I/O、绘制、定时器这些异步事件，都是通过事件队列驱动主线程执行的。

3.1 用Future发起异步任务

Dart 为 Event Queue 的任务建立提供了一层封装，叫作 Future。Future 还提供了链式调用的能力，可以在异步任务执行完毕后依次执行链路上的其他函数体。

new Future((){
    //  doing something
});

微任务是由 scheduleMicroTask 建立的。如下所示，这段代码会在下一个事件循环中输出一段字符串：

scheduleMicrotask(() => print('This is a microtask'));

链式调用：

Future(() => print('Running in Future 1'));//下一个事件循环输出字符串

Future(() => print(‘Running in Future 2'))
  .then((_) => print('and then 1'))
  .then((_) => print('and then 2’));//上一个事件循环结束后，连续输出三段字符串

Dart 会将异步任务的函数执行体放入事件队列，然后立即返回，后续的代码继续同步执行。而当同步执行的代码执行完毕后，事件队列会按照加入事件队列的顺序（即声明顺序），依次取出事件，最后同步执行 Future 的函数体及后续的 then。这意味着，then 与 Future 函数体共用一个事件循环。而如果 Future 有多个 then，它们也会按照链式调用的先后顺序同步执行，同样也会共用一个事件循环。

如果 Future 执行体已经执行完毕了，但你又拿着这个 Future 的引用，往里面加了一个 then 方法体，这时 Dart 会如何处理呢？面对这种情况，Dart 会将后续加入的 then 方法体放入微任务队列，尽快执行。

//f1比f2先执行
Future(() => print('f1'));
Future(() => print('f2'));

//f3执行后会立刻同步执行then 3
Future(() => print('f3')).then((_) => print('then 3'));

//then 4会加入微任务队列，尽快执行
Future(() => null).then((_) => print('then 4'));
结果: f1 f2 f3 then 3 then 4

4. 异步函数

Future 是异步任务的封装，借助于 await 与 async，我们可以通过事件循环实现非阻塞的同步等待。Dart 中的 await 并不是阻塞等待，而是异步等待。Dart 会将调用体的函数也视作异步函数，将等待语句的上下文放入 Event Queue 中，一旦有了结果，Event Loop 就会把它从 Event Queue 中取出，等待代码继续执行。

将async关键字作为方法声明的后缀时，具有如下意义

被修饰的方法会将一个 Future 对象作为返回值
该方法会同步执行其中的方法的代码直到第一个 await 关键字，然后它暂停该方法其他部分的执行；
一旦由 await 关键字引用的 Future 任务执行完成，await的下一行代码将立即执行。

// 导入io库，调用sleep函数
import 'dart:io';

// 模拟耗时操作，调用sleep函数睡眠2秒
doTask() async{
  await sleep(const Duration(seconds:2));
  return "Ok";
}

// 定义一个函数用于包装
test() async {
  var r = await doTask();
  print(r);
}

void main(){
  print("main start");
  test();
  print("main end");
}
结果：
main start
main end
Ok

我们先来看下这段代码。第二行的 then 执行体 f2 是一个 Future，为了等它完成再进行下一步操作，我们使用了 await，期望打印结果为 f1、f2、f3、f4：

Future(()=>print('f1'))
.then((_)async=>awaitFuture(()=>print('f2')))
.then((_)=>print('f3'));
Future(()=>print('f4'));

实际上，当你运行这段代码时就会发现，打印出来的结果其实是 f1、f4、f2、f3！

分析一下这段代码的执行顺序：
按照任务的声明顺序，f1 和 f4 被先后加入事件队列。
f1 被取出并打印；
然后到了 then。then 的执行体是个 future f2，于是放入 Event Queue。
然后把 await 也放到 Event Queue 里。这个时候要注意了，Event Queue 里面还有一个 f4，我们的 await 并不能阻塞 f4 的执行。因此，Event Loop 先取出 f4，打印 f4；
然后才能取出并打印 f2，最后把等待的 await 取出，开始执行后面的 f3。

由于 await 是采用事件队列的机制实现等待行为的，所以比它先在事件队列中的 f4 并不会被它阻塞。

5. Isolate

Dart 也提供了多线程机制，即 Isolate（这个单词的中文意思是隔离）。在 Isolate 中，资源隔离做得非常好，每个 Isolate 都有自己的 Event Loop 与 Queue，Isolate 之间不共享任何资源，只能依靠消息机制通信，因此也就没有资源抢占问题。如下所示，我们声明了一个 Isolate 的入口函数，然后在 main 函数中启动它，并传入了一个字符串参数：

doSth(msg) => print(msg);

main() {
  Isolate.spawn(doSth, "Hi");
  ...
}

那么如何利用消息机制进行通信呢，下面引用了一篇文章的讲解，图画的很好。

整个消息通信过程如上图所示，两个Isolate是通过两对Port对象通信，一对Port分别由用于接收消息的ReceivePort对象，和用于发送消息的SendPort对象构成。其中SendPort对象不用单独创建，它已经包含在ReceivePort对象之中。需要注意，一对Port对象只能单向发消息，这就如同一根自来水管，ReceivePort和SendPort分别位于水管的两头，水流只能从SendPort这头流向ReceivePort这头。因此，两个Isolate之间的消息通信肯定是需要两根这样的水管的，这就需要两对Port对象。