Dart 中的并发

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

Dart 中的并发编程既指异步 API，如 Future 和 Stream，也指*隔离*，这允许您将进程移动到单独的核心。

所有 Dart 代码都在隔离中运行，从默认的主隔离开始，并可选择扩展到您显式创建的任何后续隔离。当您生成一个新的隔离时，它有自己的隔离内存和自己的事件循环。事件循环使得 Dart 中可以进行异步和并发编程。

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

当您的应用程序运行时，所有事件都会被添加到名为*事件队列*的队列中。事件可以是任何事情，从重绘 UI 的请求到用户点击和按键，再到来自磁盘的 I/O。由于您的应用程序无法预测事件发生的顺序，事件循环会按照它们入队的顺序一次处理一个事件。

事件循环的运作方式类似于此代码

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

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

例如，考虑发出网络请求

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

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

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

本节总结了 Dart 中异步编程的不同类型和语法。如果您已经熟悉 Future、Stream 和 async-await，那么您可以跳到隔离部分。

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

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

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 关键字提供了一种声明式方式来定义异步函数并使用它们的结果。

这是一个同步代码的示例，它在等待文件 I/O 时会阻塞

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

这是类似的代码，但进行了更改（突出显示）使其变为异步

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 关键字，以便在执行本机代码（文件 I/O）时，其他 Dart 代码（如事件处理程序）可以使用 CPU。使用 await 还会将 _readFileAsync() 返回的 Future<String> 转换为 String。因此，contents 变量具有隐式类型 String。

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

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

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

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

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

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

如果您想了解有关使用 async、await、Streams 和 Futures 的更多信息，请查看异步编程教程。

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

所有 Dart 代码都在隔离中运行，而不是线程。使用隔离，您的 Dart 代码可以同时执行多个独立任务，如果可用，可以使用额外的处理器核心。隔离类似于线程或进程，但每个隔离都有自己的内存和一个运行事件循环的单线程。

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

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

即使是单隔离程序也可以平稳运行。在继续到下一行代码之前，这些应用程序使用async-await等待异步操作完成。一个行为良好的应用程序会快速启动，并尽快进入事件循环。然后，该应用程序会使用异步操作在必要时迅速响应每个排队的事件。

如下图所示，每个隔离都通过运行一些 Dart 代码（如 main() 函数）开始。此 Dart 代码可能会注册一些事件监听器，例如响应用户输入或文件 I/O。当隔离的初始函数返回时，如果需要处理事件，该隔离会保留。在处理完事件后，隔离退出。

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

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

如果同步操作花费过多的处理时间，应用程序可能会变得无响应。在下图中，点击处理代码耗时过长，导致后续事件处理过晚。应用程序可能会出现冻结，并且它执行的任何动画都可能不流畅。

在客户端应用程序中，耗时过长的同步操作的结果通常是 卡顿（不流畅）的 UI 动画。更糟糕的是，UI 可能会完全无响应。

如果您的应用程序的 UI 由于耗时的计算而变得无响应——例如解析大型 JSON 文件——请考虑将该计算卸载到工作器隔离区，通常称为后台工作器。一个常见的例子，如下图所示，是生成一个简单的工人隔离区，该隔离区执行计算然后在退出。工作器隔离区在退出时以消息的形式返回其结果。

工作器隔离区可以执行 I/O（例如，读取和写入文件）、设置定时器等等。它有自己的内存，并且不与主隔离区共享任何状态。工作器隔离区可以阻塞而不会影响其他隔离区。

在 Dart 中，根据使用场景，有两种使用隔离区的方法

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

在大多数情况下，建议使用 Isolate.run API 在后台运行进程。

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

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 对象，但也有一些例外

• 具有本机资源的对象，例如 Socket。
• ReceivePort
• DynamicLibrary
• Finalizable
• Finalizer
• NativeFinalizer
• Pointer
• UserTag
• 用 @pragma('vm:isolate-unsendable') 标记的类的实例

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

请注意，Isolate.spawn() 和 Isolate.exit() 抽象了 SendPort 对象，因此它们也受相同的限制。

可以并行运行的隔离区数量是有限制的。此限制不影响 Dart 中隔离区之间通过消息进行的标准异步通信。您可以同时运行数百个隔离区并取得进展。隔离区以轮询方式在 CPU 上调度，并且经常相互让步。

隔离区只能在纯 Dart 之外进行同步通信，使用通过 FFI 的 C 代码来实现。如果隔离区的数量超过限制，除非采取特殊措施，否则尝试通过 FFI 调用中的同步阻塞在隔离区之间进行同步通信可能会导致死锁。此限制不是硬编码为特定数字，它是根据 Dart VM 可用于 Dart 应用程序的堆大小计算的。

为了避免这种情况，执行同步阻塞的 C 代码需要在执行阻塞操作之前离开当前隔离区，并在从 FFI 调用返回到 Dart 之前重新进入它。阅读关于 Dart_EnterIsolate 和 Dart_ExitIsolate 以了解更多信息。

所有 Dart 应用程序都可以使用 async-await、Future 和 Stream 进行非阻塞的、交错的计算。然而，Dart Web 平台不支持隔离区。Dart Web 应用程序可以使用 Web Workers 在类似于隔离区的后台线程中运行脚本。但是，Web Workers 的功能和能力与隔离区略有不同。

例如，当 Web Workers 在线程之间发送数据时，它们会来回复制数据。数据复制可能非常慢，尤其是对于大型消息。隔离区也这样做，但也提供可以更有效地传输保存消息的内存的 API。

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

• 如果您正在使用许多隔离区，请考虑使用 Flutter 中的 IsolateNameServer，或者 package:isolate_name_server，它为非 Flutter Dart 应用程序提供类似的功能。
• 阅读更多关于 Actor 模型的信息，Dart 的隔离区是基于该模型构建的。
• 关于 Isolate API 的其他文档
  • Isolate.exit()
  • Isolate.spawn()
  • ReceivePort
  • SendPort

除非另有说明，本网站上的文档反映了 Dart 3.6.0。页面最后更新于 2024-11-17。 查看源代码 或 报告问题。