内容

Dart 中的并发

此页面包含有关 Dart 中并发编程工作原理的概念性概述。它从高层次解释了事件循环、异步语言特性和隔离。有关在 Dart 中使用并发的更多实用代码示例,请阅读异步支持页面和隔离页面。

Dart 中的并发编程既指异步 API(例如 FutureStream),也指隔离,它允许你将进程移动到单独的核心。

所有 Dart 代码都在隔离中运行,从默认主隔离开始,并根据需要扩展到你明确创建的任何后续隔离。当你生成新的隔离时,它有自己的隔离内存和自己的事件循环。事件循环是 Dart 中实现异步和并发编程的机制。

事件循环

#

Dart 的运行时模型基于事件循环。事件循环负责执行程序的代码、收集和处理事件等。

随着应用程序的运行,所有事件都会添加到一个队列中,称为事件队列。事件可以是任何内容,从重新绘制 UI 的请求到用户点击和击键,再到磁盘的 I/O。由于你的应用无法预测事件发生的顺序,因此事件循环会按队列中的顺序逐个处理事件。

A figure showing events being fed, one by one, into the
event loop

事件循环的功能类似于此代码

dart
while (eventQueue.waitForEvent()) {
  eventQueue.processNextEvent();
}

此示例事件循环是同步的,并且在单个线程上运行。但是,大多数 Dart 应用程序需要一次执行多项任务。例如,客户端应用程序可能需要执行 HTTP 请求,同时还要监听用户点击按钮。为了处理这种情况,Dart 提供了许多异步 API,例如Future、Stream 和 async-await。这些 API 围绕此事件循环构建。

例如,考虑发出网络请求

dart
http.get('https://example.com').then((response) {
  if (response.statusCode == 200) {
    print('Success!')'
  }  
}

当此代码到达事件循环时,它会立即调用第一个子句 http.get,并返回一个 Future。它还告诉事件循环在 HTTP 请求解决之前保留 then() 子句中的回调。发生这种情况时,它应执行该回调,并将请求的结果作为参数传递。

Figure showing async events being added to an event loop and
holding onto a callback to execute later
.

此模型通常是事件循环处理 Dart 中所有其他异步事件的方式,例如 Stream 对象。

异步编程

#

本部分总结了 Dart 中异步编程的不同类型和语法。如果您已经熟悉 FutureStream 和 async-await,则可以跳至 隔离部分

Future

#

Future 表示异步操作的结果,该操作最终将以值或错误完成。

在此示例代码中,Future<String> 的返回类型表示最终提供 String 值(或错误)的承诺。

dart
Future<String> _readFileAsync(String filename) {
  final file = File(filename);

  // .readAsString() returns a Future.
  // .then() registers a callback to be executed when `readAsString` resolves.
  return file.readAsString().then((contents) {
    return contents.trim();
  });
}

async-await 语法

#

asyncawait 关键字提供了一种声明方式来定义异步函数并使用其结果。

下面是一些同步代码的示例,它们在等待文件 I/O 时会阻塞

dart
const String filename = 'with_keys.json';

void main() {
  // Read some data.
  final fileData = _readFileSync();
  final jsonData = jsonDecode(fileData);

  // Use that data.
  print('Number of JSON keys: ${jsonData.length}');
}

String _readFileSync() {
  final file = File(filename);
  final contents = file.readAsStringSync();
  return contents.trim();
}

下面是类似的代码,但进行了更改(突出显示)以使其异步

dart
const String filename = 'with_keys.json';

void main() async {
  // Read some data.
  final fileData = await _readFileAsync();
  final jsonData = jsonDecode(fileData);

  // Use that data.
  print('Number of JSON keys: ${jsonData.length}');
}

Future<String> _readFileAsync() async {
  final file = File(filename);
  final contents = await file.readAsString();
  return contents.trim();
}

main() 函数在 _readFileAsync() 前面使用 await 关键字,以允许其他 Dart 代码(例如事件处理程序)在原生代码(文件 I/O)执行时使用 CPU。使用 await 还会将 _readFileAsync() 返回的 Future<String> 转换为 String。因此,contents 变量具有隐式类型 String

如下图所示,Dart 代码在 readAsString() 在 Dart 运行时或操作系统中执行非 Dart 代码时暂停。一旦 readAsString() 返回值,Dart 代码执行将恢复。

Flowchart-like figure showing app code executing from start to exit, waiting
for native I/O in between

Stream

#

Dart 还以流的形式支持异步代码。流在未来提供值并随着时间的推移重复提供值。随着时间的推移提供一系列 int 值的承诺具有类型 Stream<int>

在以下示例中,使用 Stream.periodic 创建的流每秒重复发出一个新的 int 值。

dart
Stream<int> stream = Stream.periodic(const Duration(seconds: 1), (i) => i * i);

await-for 和 yield

#

Await-for 是一种 for 循环,它在提供新值时执行循环的每个后续迭代。换句话说,它用于“循环”流。在此示例中,将从函数 sumStream 发出新值,因为从作为参数提供的流中发出了新值。在返回值流的函数中使用 yield 关键字,而不是 return

dart
Stream<int> sumStream(Stream<int> stream) async* {
  var sum = 0;
  await for (final value in stream) {
    yield sum += value;
  }
}

如果您想了解有关使用 asyncawaitStreamFuture 的更多信息,请访问 异步编程代码实验室

隔离

#

除了 异步 API 之外,Dart 还通过隔离支持并发性。大多数现代设备都具有多核 CPU。为了利用多个内核,开发人员有时会使用并发运行的共享内存线程。但是,共享状态并发性容易出错,并且可能导致代码复杂。

Dart 代码在隔离区中运行,而不是在线程中。使用隔离区,你的 Dart 代码可以一次执行多个独立的任务。隔离区类似于线程或进程,但每个隔离区都有自己的内存和一个运行事件循环的单线程。

每个隔离区都有自己的全局字段,确保隔离区中的任何状态都无法从任何其他隔离区访问。隔离区只能通过消息传递相互通信。隔离区之间没有共享状态,这意味着并发复杂性,如 互斥锁或锁数据竞争 不会在 Dart 中发生。也就是说,隔离区并不能完全防止竞争条件。有关此并发模型的更多信息,请阅读 Actor 模型

使用隔离区,你的 Dart 代码可以一次执行多个独立的任务,如果可用,可以使用额外的处理器内核。隔离区类似于线程或进程,但每个隔离区都有自己的内存和一个运行事件循环的单线程。

主隔离区

#

在大多数情况下,你根本不需要考虑隔离区。默认情况下,Dart 程序在主隔离区中运行。这是程序开始运行和执行的线程,如下图所示

A figure showing a main isolate, which runs , responds to events,
and then exits

即使是单隔离区程序也可以顺利执行。在继续执行下一行代码之前,这些应用使用 async-await 等待异步操作完成。表现良好的应用启动迅速,尽快进入事件循环。然后,应用会及时响应每个排队的事件,必要时使用异步操作。

隔离区生命周期

#

如下图所示,每个隔离区首先运行一些 Dart 代码,例如 main() 函数。此 Dart 代码可能会注册一些事件侦听器,例如响应用户输入或文件 I/O。当隔离区的初始函数返回时,如果需要处理事件,隔离区将保留。处理完事件后,隔离区退出。

A more general figure showing that any isolate runs some code, optionally responds to events, and then exits

事件处理

#

在客户端应用中,主隔离区的事件队列可能包含重新绘制请求和点击和其他 UI 事件的通知。例如,下图显示了一个重新绘制事件,然后是一个点击事件,然后是两个重新绘制事件。事件循环从队列中按先进先出的顺序获取事件。

A figure showing events being fed, one by one, into the event loop

main() 退出后,事件处理在主隔离区中发生。在下图中,在 main() 退出后,主隔离区处理第一个重新绘制事件。之后,主隔离区处理点击事件,然后处理重新绘制事件。

如果同步操作占用太多处理时间,应用可能会变得无响应。在下图中,点击处理代码花费的时间太长,因此后续事件处理得太晚。应用可能看起来冻结了,并且它执行的任何动画都可能不流畅。

A figure showing a tap handler with a too-long execution time

在客户端应用中,过于冗长的同步操作的结果通常是 不流畅(非平滑)的 UI 动画。更糟的是,UI 可能会完全没有响应。

后台工作线程

#

如果你的应用的 UI 由于耗时的计算而没有响应——例如 解析一个大型 JSON 文件——请考虑将该计算卸载到一个工作者隔离,通常称为后台工作者。一个常见的情况,如下图所示,是生成一个执行计算然后退出的简单工作者隔离。工作者隔离在退出时通过消息返回其结果。

A figure showing a main isolate and a simple worker isolate

工作者隔离可以执行 I/O(例如读写文件)、设置计时器等。它有自己的内存,并且不与主隔离共享任何状态。工作者隔离可以阻塞,而不会影响其他隔离。

使用隔离区

#

在 Dart 中有两种使用隔离的方法,具体取决于用例

  • 使用 Isolate.run() 在单独的线程上执行单个计算。
  • 使用 Isolate.spawn() 创建一个隔离,该隔离将随着时间的推移处理多个消息,或一个后台工作者。有关使用长期隔离的更多信息,请阅读 隔离 页面。

在大多数情况下,Isolate.run 是在后台运行进程的推荐 API。

Isolate.run()

#

静态 Isolate.run() 方法需要一个参数:将在新生成的隔离上运行的回调。

dart
int slowFib(int n) => n <= 1 ? 1 : slowFib(n - 1) + slowFib(n - 2);

// Compute without blocking current isolate.
void fib40() async {
  var result = await Isolate.run(() => slowFib(40));
  print('Fib(40) = $result');
}

性能和隔离区组

#

当一个隔离调用 Isolate.spawn() 时,这两个隔离具有相同的可执行代码,并且处于相同的隔离组中。隔离组支持性能优化,例如共享代码;一个新的隔离会立即运行隔离组拥有的代码。另外,Isolate.exit() 仅在隔离处于相同的隔离组时才起作用。

在某些特殊情况下,你可能需要使用 Isolate.spawnUri(),它使用指定 URI 处的代码副本设置新的隔离。但是,spawnUri()spawn() 慢得多,并且新的隔离不在其生成者的隔离组中。另一个性能后果是,当隔离处于不同的组中时,消息传递会更慢。

隔离区的限制

#

隔离不是线程

#

如果你从一种具有多线程功能的语言转到 Dart,你可能会合理地期望隔离的行为像线程一样,但事实并非如此。每个隔离都有自己的状态,确保隔离中的任何状态都无法从任何其他隔离中访问。因此,隔离受限于它们访问自己内存的能力。

例如,如果您有一个具有全局可变变量的应用程序,那么该变量将成为您生成的隔离中的一个单独变量。如果您在生成的隔离中改变该变量,它在主隔离中将保持不变。这就是隔离的预期功能,当您考虑使用隔离时,这一点很重要。

消息类型

#

通过 SendPort 发送的消息几乎可以是任何类型的 Dart 对象,但有几个例外

除了这些例外,任何对象都可以发送。请查看 SendPort.send 文档了解更多信息。

请注意,Isolate.spawn()Isolate.exit()SendPort 对象进行抽象,因此它们受相同的限制。

网络上的并发

#

所有 Dart 应用都可以使用 async-awaitFutureStream 进行非阻塞、交错计算。但是,Dart Web 平台 不支持隔离。Dart Web 应用可以使用 Web 工作线程 在类似于隔离的后台线程中运行脚本。不过,Web 工作线程的功能和能力与隔离略有不同。

例如,当 Web 工作线程在线程之间发送数据时,它们会来回复制数据。但是,数据复制可能非常慢,尤其是对于大型消息。隔离执行相同操作,但还提供可以更有效地传输保存消息的内存的 API。

创建 Web 工作线程和隔离的方式也不同。您只能通过声明一个单独的程序入口点并单独编译它来创建 Web 工作线程。启动 Web 工作线程类似于使用 Isolate.spawnUri 启动隔离。您还可以使用 Isolate.spawn 启动隔离,这需要的资源更少,因为它重用了与生成隔离相同的某些代码和数据。Web 工作线程没有等效的 API。

其他资源

#