关于flutter:一文学会Dart事件循环及异步调用

异步代码在 Dart 中随处可见。许多库函数返回 Future 对象，您能够注册处理程序来响应事件，如鼠标单击、文件 I / O 实现和计时。

本文形容了 Dart 的事件循环架构，您就能够编写出更好的更少问题的异步代码。您将学习如何应用 Future，并且可能预测程序的执行程序。

<u> 留神：本文中的所有内容既实用于原生运行的 Dart 应用程序（应用 Dart 虚拟机），也实用于曾经编译成 JavaScript 的 Dart 应用程序（dart2js 的输入）。本文应用 Dart 一词来辨别 Dart 应用程序和其余语言编写的软件。</u>

在浏览本文之前，你应该相熟 Future 和错误处理的基本知识。

如果你写过 UI 代码，你可能曾经相熟了事件循环和事件队列的概念。它们确保了图形操作和事件（如鼠标点击）一次只解决一个。

事件循环和队列

事件循环的工作是从事件队列中获取一个事件并解决它，只有队列中有事件，就反复这两个步骤。

队列中的事件可能代表用户输出，文件 I / O 告诉，计时器等。例如，上面是事件队列的图片，其中蕴含计时器和用户输出事件：

你可能在其余的语言中相熟这些。当初咱们来谈谈 dart 语言是如何实现的。

Dart 的单线程

一旦一个 Dart 函数开始执行，它将继续执行直到退出。换句话说，Dart 函数不能被其余 Dart 代码打断。

如下图所示，一个 Dart 程序开始执行的第一步是主 isolate 执行 main()函数，当 main()退出后，主 isolate 线程开始一一处理程序事件队列上的所有事件。

实际上，这有点过于简化了。

Dart 应用程序的事件循环带有两个队列——事件队列和微工作队列。

事件队列蕴含所有内部事件:I/O、鼠标事件、绘图事件、计时器、Dart isolate 之间的通信，等等。

微工作队列是必要的，因为事件处理代码有时须要稍后实现一个工作，但在将控制权返回到事件循环之前。例如，当一个可察看对象发生变化时，它将几个渐变变动组合在一起，并同步地报告它们。微工作队列容许可察看对象在 DOM 显示不统一状态之前报告这些渐变变动。

事件队列蕴含来自 Dart 和零碎中其余的事件，微工作队列只蕴含来自 Dart 外围代码的事件。

如下图所示，当 main()函数退出时，事件循环开始工作。首先，它以 FIFO（先进先出）程序执行所有微工作。而后，它使事件队列中的第一项出队并解决，而后它反复这个循环: 执行所有微工作，而后解决事件队列上的下一事件。一旦两个队列都为空并且不会再产生任何事件，应用程序的嵌入程序 (如浏览器或测试框架) 就能够开释应用程序。

<u> 留神: 如果 web 应用程序的用户敞开了它的窗口，那么 web 应用程序可能会在其事件队列为空之前强行退出。</u>

重要：当事件循环正在执行微工作队列中的工作时，事件队列会卡住：应用程序无奈绘制图形、解决鼠标点击、对 I / O 做出反馈等。

只管能够预测工作执行的程序，但不能精确预测事件循环何时将工作从队列中移除。Dart 事件处理零碎基于单线程循环; 它不是基于任何类型的工夫规范。例如，当您创立一个提早的工作时，事件将在您指定的工夫进入队列。他还是要期待事件队列中它之前的所有事件 (包含微工作队列中的每一个事件) 全副执行完后，能力失去执行。（延时工作不是插队，是在指定工夫进入队列）

如果您的代码有依赖关系，请以显式的形式编写。显式依赖关系帮忙其余开发人员了解您的代码，并且使您的程序更能抵制代码重构。

上面是一个谬误编码方式的例子:

// 因为在设置变量和应用变量之间没有明确的依赖关系，所以不好。future.then((){... 设置一个重要变量...)。Timer.run(() {... 应用重要变量...})。

相同，像这样写代码:

// 更好，因为依赖关系是显式的。

future.then(…设置一个重要的变量…)

then((_){…应用重要的变量…});

在应用该变量之前必须先设置它。(如果您心愿即便呈现谬误也能执行代码，那么能够应用 whenComplete()而不是 then()。)

如果应用变量须要工夫并且能够在当前实现，请思考将代码放在新的 Future 中：

// 可能更好: 显式依赖加上提早执行。future.then(…设置一个重要的变量…)

then((_) {new Future((){…应用重要的变量…})});

应用新的 Future 使事件循环有机会解决事件队列中的其余事件。下一节将具体介绍提早运行的调度代码。

当您须要指定一些须要提早执行的代码时，能够应用 dart：async 库提供的以下 API：

Future 类，它将一个我的项目增加到事件队列的开端。

顶级的 scheduleMicrotask()函数，它将一个我的项目增加到微工作队列的开端。

应用这些 api 的示例在下一节中。事件队列:new Future()和微工作队列:scheduleMicrotask()

尽可能的在事件队列上调度工作，应用 Future。应用事件队列有助于放弃微工作队列较短，缩小微工作队列影响事件队列的可能。

如果一个工作须要在解决任何来自事件队列的事件之前实现，那么你通常应该先执行该函数。如果不能先执行，那么应用 scheduleMicrotask()将这个工作增加到微工作队列中。

要在事件队列上调度工作，能够应用 new Future()或 new Future.delayed()。这是 dart:async 库中定义的两个 Future 的构造函数。

留神：您也能够应用 Timer 安顿工作，然而如果 Timer 工作中产生任何未捕捉的异样，您的应用程序将退出。相同，咱们倡议应用 Future，它建设在 Timer 之上，并减少了诸如检测工作实现和对谬误进行响应的性能。

要立刻将一个事件放到事件队列中，应用 new Future():

// 在事件队列中增加工作。new Future((){/……代码就在这里……});

您能够增加对 then()或 whenComplete()的调用，以便在新的 Future 实现后立刻执行一些代码。例如，当 new Future 的工作来到队列时，以下代码输入“42”:

new Future(() => 21)
    .then((v) => v*2)
    .then((v) => print(v));

应用 new Future.delayed()在一段时间后在队列中退出一个事件:

// 一段时间之后，将事件退出队列
new Future.delayed(const Duration(seconds:1), () {// ... 代码在这里...});

只管后面的示例在一秒后将工作增加到事件队列中，但该工作只有在主 isolate 闲暇、微工作队列为空以及之前在事件队列中入队的工作全副执行完后能力执行。例如，如果 main()函数或事件处理程序正在运行一个简单的计算，则工作只有在该计算实现后能力执行。在这种状况下，提早可能远不止一秒。

对于 future 的重要细节:

1 传递给 Future 的 then()办法的函数在 Future 实现时立刻执行。(函数没有进入队列，只是被调用了)

2 如果 Future 在调用 then（）之前曾经实现，则将一个工作增加到微工作队列，而后该工作执行传递给 then（）的函数。

3 Future（）和 Future.delayed（）构造函数不会立刻实现；他们将一个我的项目增加到事件队列。

4 value()构造函数在微工作中实现，相似于 #2

5 Future.sync（）构造函数立刻执行其函数参数，并且（除非该函数返回 Future，如果返回 future 代码会进入事件队列）在微工作中实现，相似于#2。（Future.sync(FutureOr<T> computation())该函数承受一个 function 参数）

async 库将 scheduleMicrotask()定义为一个顶级函数。你能够像这样调用 scheduleMicrotask():

scheduleMicrotask(() {// ... 代码在这里...});

因为 bug 9001 和 9002，第一次调用 scheduleMicrotask()会将一个创立微工作队列的事件放在事件队列中；此事件创立微工作队列，并将指定给 scheduleMicrotask()的函数放入微工作队列，只有微工作队列至多有一个事件，后续对 scheduleMicrotask() 的调用就会正确地增加到微工作队列中。一旦微工作队列为空，下次调用 scheduleMicrotask()时必须从新创立（意味着第一次调用 scheduleMicrotask()不会间接进入微工作队列立刻执行，会在事件队列上先插入一个创立微工作队列的事件，这个事件还是要在事件队列中排队）。

这些谬误的后果是: 应用 scheduleMicrotask()调度的第一个工作仿佛位于事件队列上。

（译者注：dart2.9 会将第一次调用 scheduleMicrotask()时，将此代码插入事件队列的第一位）

向微工作队列增加工作的一种办法是在曾经实现的 Future 上调用 then()。无关更多信息，请参阅前一节（对于 future 的重要）

当初您曾经浏览了对于调度工作的所有内容，让咱们测试一下您的了解。

请记住，您不应该依赖 Dart 的事件队列实现来指定工作程序。实现可能会发生变化，Future 的 then（）和 whenComplete（）办法是更好的抉择。不过，如果您能正确答复上面这些问题，你学会了。

这个示例打印出什么?

import 'dart:async';
void 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)

这个程序应该你能预料到的，因为示例代码分三批执行:

1 main()函数中的代码

2 微工作队列中的工作(scheduleMicrotask())

3 事件队列中的工作 (new Future() 或 new Future.delayed())

请记住，main()函数中的所有调用都是从头到尾同步执行的。首先 main()调用 print()，而后调用 scheduleMicrotask()，再调用 new Future.delayed()，而后调用 new Future()，以此类推。只有回调 – 作为 scheduleMicrotask()、new Future.delayed()和 new Future()的参数代码才会在前面的工夫执行。

留神: 目前，如果正文掉对 scheduleMicrotask()的第一个调用，那么对 #2 和#3 的回调将在微工作#2 之前执行。这是因为 bug 9001 和 9002 造成的，如微工作队列: scheduleMicrotask()中所述。

这里有一个更简单的例子。如果您可能正确地预测这段代码的输入，就会失去一个闪亮的星星。

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

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

  new Future(() => print('future #2 of 4'))
      .then((_) => print('future #2a'))
      .then((_) {print('future #2b');
        scheduleMicrotask(() => print('microtask #0 (from future #2b)'));
      })
      .then((_) => print('future #2c'));

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

  new Future(() => print('future #3 of 4'))
      .then((_) => new Future(() => print('future #3a (a new future)')))
      .then((_) => print('future #3b'));

  new Future(() => print('future #4 of 4'));
  scheduleMicrotask(() => print('microtask #3 of 3'));
  print('main #2 of 2');
}

假如谬误 9001/9002 没有修复，输入如下:

main #1 of 2
main #2 of 2
microtask #1 of 3
microtask #2 of 3
microtask #3 of 3
future #2 of 4
future #2a
future #2b
future #2c
future #3 of 4
future #4 of 4
microtask #0 (from future #2b)
future #3a (a new future)
future #3b
future #1 (delayed)

（译者注）

这是译者在 dart2.9 上运行的后果。dart 程序会在第一次创立微工作队列时，将创立微工作队列的代码插入到事件队列的第一位，相当于插队。

原作者说的 bug 曾经修复了

你当初应该理解 Dart 的事件循环以及 dart 如何安顿工作。以下是 Dart 中事件循环的一些次要概念:

Dart 应用程序的事件循环应用两个队列执行工作: 事件队列和微工作队列。

事件队列有来自 Dart(futures、计时器、isolate messages)和零碎 (用户操作、I/ O 等) 的事件。

目前，微工作队列只有来自 Dart 外围代码的事件, 如果你想让你的代码进入微工作队列执行，应用 scheduleMicrotask()。

事件循环在退出队列并解决事件队列上的下一项之前先清空微工作队列。

一旦两个队列都为空，应用程序就实现了它的工作，并且 (取决于它的嵌入程序) 能够退出。

main()函数和来自微工作和事件队列的所有我的项目都运行在 Dart 应用程序的主 isolates 上。

如果可能，将其放在事件队列中 (应用 new Future() 或 new Future.delayed())。

应用 Future 的 then()或 whenComplete()办法指定工作程序。

为了防止耗尽事件循环，请放弃微工作队列尽可能短。

为了放弃应用程序的响应性，防止在任何一个事件循环中执行计算密集型工作。

要执行计算密集型工作，请创立额定的 isolates 或者 workers。

（译者原本想本人总结一篇 dart 事件循环和异步应用的文章，不过翻译完这篇文章之后没有这个必要了，这篇文章曾经将全副的细节形容分明了）
[英文文章地址]
(https://dart.cn/articles/arch…:~:text=A%20Dart%20app%20has%20a,queue%20and%20the%20microtask%20queue.&text=First,%20it%20executes%20any%20microtasks,item%20on%20the%20event%20queue.)

学习英语对程序员来说十分必要

关于flutter:一文学会Dart事件循环及异步调用

基本概念

dart 的事件循环和队列

提醒：链式调用 future 指定工作程序

如何安顿工作

应用适当的队列(通常是事件队列)

事件队列: new Future()

微工作队列：scheduleMicrotask()

必要时应用 isolates 或 workers

练习

Question #1

Question #2

总结

当你安顿一项事件时，遵循以下规定: