Flutter开发指南之理论篇：Dart语法05（单线程模型，事件循环模型，Isolate）

 

总目录

​​Flutter开发指南之理论篇：Dart语法01（数据类型，变量，函数）​​

​​Flutter开发指南之理论篇：Dart语法02（运算符，循环，异常）​​

​​Flutter开发指南之理论篇：Dart语法03（类，泛型）​​

​​Flutter开发指南之理论篇：Dart语法04（库，异步，正则表达式）​​

​​Flutter开发指南之理论篇：Dart语法05（单线程模型，事件循环模型，Isolate）​​

Flutter开发指南之理论篇：Flutter基础01（架构，设计思想）

---

 Dart是一门面向对象语言，它针对web 和移动设备开发进行了优化，主要特点为：

• 一切皆对象！无论是数字，函数还是null，所有对象继承自Object类；
• 声明一个变量时可以不指定具体类型，Dart可以自动推断类型；
• Dart支持顶层函数，函数是一等对象，且函数可作为参数传递；
• Dart使用​​_​​​开头表示私有属性，没有关键字​​public​​​，​​protected​​​和​​private​​；

1. 单线程模型

 众所周知，在Java中使用​​多线程​​​来处理并发任务，适量并合适地使用多线程，能够极大地提高资源的利用率和程序运行效率，但是缺点也比较明显，比如​​过度开启线程会带来额外的资源和性能消耗​​​或​​多线程共享内存容易出现死锁​​​等。实际上，在APP的使用过程中，多数处理空闲状态，并不需要进行密集或高并发的处理，因此从某些意义上来说，多线程显得有点多余。正是因为如此，Dart作为一种新的语言，通过引​​单线程模型​​很好地处理了并发任务对多线程的依赖。

1.1 单线程模型

 Dart是一种单线程语言，因此Dart程序没有主线程和子线程之分，而在Dart中线程并不是指​​Thread​​​，而是指​​Isolate​​​。因为Dart没有线程的概念，只有​​Isolate​​​，每个​​Isolate​​​都是隔离的，并不会共享内存。所有的Dart代码都是在​​Isolate​​​中运行，它就像机器上的一个小空间，具有自己的私有内存块和一个运行着​​事件循环模型​​的单线程。也就是说，一旦某个Dart函数开始执行，它将执行到这个函数的结束而不被其他Dart代码打断，这就是单线程的特性。

 默认情况下，Dart程序只有一个​​Isolate​​​(未自己创建的情况下)，而这个​​Isolate​​​就是​​Main Isolate​​​。也就是说，一个Dart程序是从​​Main Isolate​​​的main函数开始的，而在main函数结束后，​​Main isolate​​​线程开始一个一个处理事件循环模型队列中的每一​​事件(Event)​​​。上图描述的就是​​Main Isolate​​的消息循环模型。

1.2 事件循环模型

 也许你会问，既然Dart是一种单线程语言，那么是不是就意味着Dart无法并发处理异步任务了？此言差矣。前面说到，所有的Dart程序都在​​Isolate​​​中运行，每个​​Isolate​​​拥有自己的私有内存块和一个​​事件循环模型​​​，其中，​​事件循环模型​​就是用来处理各种事件，比如点输入/输出，点击，定时器以及​异步任务​等。下图描述了一个​​Isolate​​​的​​事件循环模型​​的整个流程：

 从上图可知，Dart事件循环机制由​​一个消息循环(event looper)​​​和​​两个消息队列​​​构成，其中，两个消息队列是指​​事件队列(event queue)​​​和​​微任务队列(Microtask queue)​​。该机制运行原理为：

• 首先，Dart程序从main函数开始运行，待main函数执行完毕后，event looper开始工作；
• 然后，event looper优先遍历执行Microtask队列所有事件，直到Microtask队列为空；
• 接着，event looper才遍历执行Event队列中的所有事件，直到Event队列为空；
• 最后，视情况退出循环。

 为了进一步理解，我们解释下上述三个概念：

​（1）消息循环(​​Event Looper​​)​

 顾名思义，消息循环就是指一个永不停歇且不能阻塞的循环，它将不停的尝试从​​微任务队列​​​和​​事件队列​​中获取事件(event)进行处理，而这些Event包括了用户输入，点击，Timer，文件IO等。

​（2）事件队列(​​Event queue​​)​

 该队列的事件来源于​​外部事件​​​和​​Future​​​，其中，​​外部事件​​​主要包括I/O，手势，绘制，计时器和isolate相互通信的message等，而​​Future​​​主要是指用户自定义的异步任务，通过创建Future类实例来向事件队列添加事件。需要注意的是，当Event looper正在处理​​Microtask Queue​​​时，​​Event queue​​​会被阻塞，此时APP将无法进行UI绘制，响应用户输入和I/O等事件。下列示例演示了向​​Event queue​​中添加一个异步任务事件：

main(List<String> args) {
  print('main start...')
  
  var futureInstance = Future<String>(() => "12345");
  futureInstance.then((res) {
    print(res);
  }).catchError((err) {
    print(err);
  });
  
  print('main end...')
}

// 打印结果：
//      main start...
//      main end...
//      12345

​（3）微任务队列(​​Microtask queue​​)​

 该队列的事件来源与当前isolate的内部或通过​​scheduleMicrotask​​​函数创建，Microtask一般用于非常短的内部异步动作，并且任务量非常少，如果微任务非常多，就会造成​​Event queue​​​排不上队，会阻塞​​Event queue​​​的执行造成应用ANR，因为​​Microtask queue​​​的优先级高于​​Event queue​​​。因此，大多数情况下的任务优先考虑使用​​Event queue​​​，不到万不得已不要使用​​Microtask queue​​​。下列​​示例​​演示了两个事件队列执行情况：

import 'dart:async';
main() {
  print('main #1 of 2');
  scheduleMicrotask(() => print('microtask #1 of 2'));

  new Future.delayed(new Duration(seconds:1),
                     () => print('future #1 (delayed)'));
  new Future(() => print('future #2 of 3'));
  new Future(() => print('future #3 of 3'));

  scheduleMicrotask(() => print('microtask #2 of 2'));

  print('main #2 of 2');
}

// 执行结果：
//      main #1 of 2
//      main #2 of 2
//      microtask #1 of 2
//      microtask #2 of 2
//      future #2 of 3
//      future #3 of 3
//      future #1 (delayed)

2. Isolate

 大多数计算机中，甚至在移动平台上，都在使用多核CPU。 为了有效利用多核性能，开发者一般使用共享内存数据来保证多线程的正确执行。 然而多线程共享数据通常会导致很多潜在的问题，并导致代码运行出错。Dart作为一种新语言，为了缓解上述问题，提出了​​Isolate(隔离区)​​​的概念，即Dart没有线程的概念，只有​​Isolate​​​，所有的Dart代码都是在​​Isolate​​中运行，它就像是机器上的一个小空间，具有自己的私有内存堆和一个运行着Event Looper的单个线程。

 通常，一个Dart应用对应着一个​​Main Isolate​​​，且应用的入口即为该Isolate的main函数。当然，我们也可以创建其它的​​Isolate​​​，由于​​Isolate​​​的内存堆是私有的，因此这些​​Isolate​​​的内存都不会被其它​​Isolate​​​访问。假如不同的​​Isolate​​​需要通信(单向/双向)，就只能通过向对方的事件循环队列里写入任务，并且它们之间的通讯方式是通过​​port(端口)​​​实现的，其中，Port又分为​​receivePort(接收端口)​​​和​​sendPort(发送端口)​​，它们是成对出现的。Isolate之间通信过程：

• 首先，当前​​Isolate​​​创建一个​​ReceivePort​​​对象，并获得对应的​​SendPort​​对象；

var receivePort = ReceivePort();
 var sendPort = receivePort.sendPort;

• 其次，创建一个新的​​Isolate​​​，并实现新​​Isolate​​要执行的异步任务，同时，将当前Isolate的SendPort对象传递给新的Isolate，以便新Isolate使用这个SendPort对象向原来的Isolate发送事件；

// 调用Isolate.spawn创建一个新的Isolate
// 这是一个异步操作，因此使用await等待执行完毕
var anotherIsolate = await Isolate.spawn(otherIsolateInit, receivePort.sendPort);

// 新Isolate要执行的异步任务
// 即调用当前Isolate的sendPort向其receivePort发送消息
void otherIsolateInit(SendPort sendPort) async {
  value = "Other Thread!";
  sendPort.send("BB");
}

• 第三，调用当前Isolate#receivePort的listen方法监听新的Isolate传递过来的数据。Isolate之间什么数据类型都可以传递，不必做任何标记。

receivePort.listen((date) {
    print("Isolate 1 接受消息：data = $date");
});

• 最后，消息传递完毕，关闭新创建的Isolate。

anotherIsolate?.kill(priority: Isolate.immediate);
anotherIsolate =null;

​示例代码如下（Isolate单向通信）：​

import 'dart:isolate';

var anotherIsolate;
var value = "Now Thread!";

void startOtherIsolate() async {
  var receivePort = ReceivePort();

  anotherIsolate = await Isolate.spawn(otherIsolateInit, receivePort.sendPort);

  receivePort.listen((date) {
    print("Isolate 1 接受消息：data = $date，value = $value");
  });
}

void otherIsolateInit(SendPort sendPort) async {
  value = "Other Thread!";
  sendPort.send("BB");
}

// 在Main Isolate创建一个新的Isolate
// 并使用Main Isolate的ReceiverPort接收新Isolate传递过来的数据
import 'DartLib.dart';

void main(){
  startOtherIsolate();
}

 执行结果：

Isolate 1 接受消息：data = BB，value = Now Thread!

3. 参考文献

​​1. Dart asynchronous programming: Isolates and event loops​​

​​2. Futures - Isolates - Event Loop​​

​​3. Flutter 真异步​​

更多内容详见微信公众号：Python研究所