Dart-3的异步模型

作者: YFBigHeart | 来源:发表于2020-10-29 11:47 被阅读0次

1-Dart的异步模型

1.1 如何处理耗时的操作呢？

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

1.2 单线程的异步操作

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

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

我们用一个生活中的例子来模拟：

你中午饿了，需要点一份外卖，点外卖的动作就是我们的调用，拿到最后点的外卖就是我们要等待的结果。
阻塞式调用： 点了外卖，不再做任何事情，就是在傻傻的等待，你的线程停止了任何其他的工作。
非阻塞式调用： 点了外卖，继续做其他事情：继续工作、打把游戏，你的线程没有继续执行其他事情，只需要偶尔去看一下有没有人敲门，外卖有没有送到即可。

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

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

这些操作都不会阻塞我们单线程的继续执行，我们的线程在等待的过程中可以继续去做别的事情，等真正有了响应，再去进行对应的处理即可。

2 Dart事件循环

2.1 什么是事件循环

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

事件循环是什么呢？

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

模拟事件循环的伪代码：

List eventQueue = []; 
var event;

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

3. Dart的异步操作

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

3.1 同步网络请求

直接看一段代码例子：

import "dart:io";

// 该模拟网络请求需要3秒钟的时间，之后返回数据；
main(List<String> args) {
  print("main function start");
  print(getNetworkData());
  print("main function end");
}

String getNetworkData() {
// 网络请求阻塞了main函数，那么意味着其后所有的代码都无法正常的继续执行
  sleep(Duration(seconds: 3));
  return "network data";
}
// 打印结果
main function start
network data
main function end

3.2 异步的网络请求

使用了Future对象来将耗时的操作放在了其中传入的函数中

Future<String> getNetworkData() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
    return "network data";
  });
}
// 打印结果
main function start
Instance of 'Future<String>' // 为什么不是 network data？
main function end

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

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

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

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("网络请求出现错误");
  });
}

// 执行结果
main function start
Instance of 'Future<String>'
main function end
// 3s后没有拿到结果，但是我们捕获到了异常
Exception: 网络请求出现错误

Future的两种状态 :

完成状态:执行Future内部的操作时

未完成状态:通常会返回一个值，或者抛出一个异常

Future的链式调用

main(List<String> args) {
  print("main function start");
  getNetworkData4().then((value1) {
    print(value1);
    return "content data2";
  }).then((value2) {
    print(value2);
    return "message data3";
  }).then((value3) {
    print(value3);
  });
  print("main function end");
}
  
  Future<String> getNetworkData4() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
     return "network data1";
  });
}

main(List<String> args) {
  print("main function start");
  getNetworkData4().then((value1) {
    print(value1);
    return "content data2";
  }).then((value2) {
    print(value2);
    return "message data3";
  }).then((value3) {
    print(value3);
  });
  print("main function end");
}
  
  Future<String> getNetworkData4() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
     return "network data1";
  });
}

Future 其他的api

main(List<String> args) {
  print("main function start");
  getNetworkData4().then((value1) {
    print(value1);
    return "content data2";
  }).then((value2) {
    print(value2);
    return "message data3";
  }).then((value3) {
    print(value3);
  });
  print("main function end");
}
  
  Future<String> getNetworkData4() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
     return "network data1";
  });
}

Future的高级用法直接去看才凡的文档 dart2 ，整理就说再说两个简单的

同步生成器和异步生成器：同步生成器Iterable和异步生成器Stream

语言学习02

Future 其他的api

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

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

Future.error(object):直接获取一个完成的Future，该Future会直接调用then的回调函数

void futureDelayed() {
  Future.delayed(Duration(seconds: 3), () {
    return "3秒后的信息";
  }).then((value) {
    print(value);
  });
}

3.3 await、async, sync

await、async是什么呢？

它们可以让我们用同步的代码格式，去实现异步的调用过程。
并且，通常一个async的函数会返回一个Future。
await只能在async函数出现，async函数返回一个Future对象，如果没有返回Future对象，则将自动包装成Future对象

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

如何生成一个Future呢？

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

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

String getNetworkData5() {
  var result = Future.delayed(Duration(seconds: 3), () {
    return "network data";
  });
    // 因为Future.delayed返回的是一个Future对象，我们不能把它看成同步的返回数据："network data"去使用
    // 也就是我们不能把这个异步的代码当做同步一样去使用
  return  "请求到的数据：" + result; // 报错，result不是String
}

现在我使用await修改下面这句代码：

你会发现，我在Future.delayed函数前加了一个await。

一旦有了这个关键字，那么这个操作就会等待Future.delayed的执行完毕，并且等待它的结果

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

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

修改后执行代码，会看到如下的错误：

错误非常明显：await关键字必须存在于async函数中。
所以我们需要将getNetworkData函数定义成async函数

在函数的()后面加上一个async关键字

// 返回的时候并不需要包装一个Future，直接返回即可，但是返回值会默认被包装在一个Future中
Future<String> getNetworkData() async {
  var result = await Future.delayed(Duration(seconds: 3), () {
    return "network data";
  });

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

3.4 微任务队列

在Dart中还存在另一个队列：微任务队列（Microtask Queue）。

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

是

640.jpeg

3.4.2 如何创建微任务

可以通过dart中async下的scheduleMicrotask来创建一个微任务：

import "dart:async";

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

如果我们有一个任务不希望它放在Event Queue中依次排队，那么就可以创建一个微任务了

Future 两个函数执行体Future函数和then 函数体，它们是加入到什么队列中的呢？

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

案例:最终的执行顺序


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

代码分析：

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被执行；

3.5 多核CPU的利用

所有的Dart代码都运行在某个isolate中，代码只能使用所属isolate的类和值。不同的isolate可以通过port发送message进行交流

在Dart中，有一个Isolate的概念，它是什么呢？

我们已经知道Dart是单线程的，这个线程有自己可以访问的内存空间以及需要运行的事件循环；
我们可以将这个空间系统称之为是一个Isolate；
比如Flutter中就有一个Root Isolate，负责运行Flutter的代码，比如UI渲染、用户交互等等；

在 Isolate 中，资源隔离做得非常好，每个 Isolate 都有自己的 Event Loop 与 Queue，

Isolate 之间不共享任何资源，只能依靠消息机制通信，因此也就没有资源抢占问题。

如果只有一个Isolate，那么意味着我们只能永远利用一个线程，这对于多核CPU来说，是一种资源的浪费。如果在开发中，我们有非常多耗时的计算，完全可以自己创建Isolate，在独立的Isolate中完成想要的计算操作

通过Isolate.spawn就可以创建了：

import "dart:isolate";

main(List<String> args) {
  Isolate.spawn(foo, "Hello Isolate");
}

void foo(info) {
  print("新的isolate：$info");
}

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

Dart-3的异步模型

1-Dart的异步模型

2 Dart事件循环

2.1 什么是事件循环

3. Dart的异步操作

3.1 同步网络请求

3.2 异步的网络请求

Future的高级用法直接去看才凡的文档 dart2 ，整理就说再说两个简单的

3.4 微任务队列

3.4.2 如何创建微任务

3.5 多核CPU的利用

Isolate通信机制

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Dart-3的异步模型

1-Dart的异步模型

2 Dart事件循环

2.1 什么是事件循环

3. Dart的异步操作

3.1 同步网络请求

3.2 异步的网络请求

Future的高级用法 直接去看 才凡的文档 dart2 ，整理就说再说两个简单的

3.4 微任务队列

3.4.2 如何创建微任务

3.5 多核CPU的利用

Isolate通信机制

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Future的高级用法直接去看才凡的文档 dart2 ，整理就说再说两个简单的