跳到正文
CH 05异步与事件Dart10 分钟阅读

Dart 异步:Future、async/await、Stream、异步错误处理

第 5 章 · Dart 异步:Future、async/await、Stream、异步错误处理

本章示例examples/ch05-async在线阅读源码下载 zip

run

$cd examples/ch05-async && dart pub get && dart run

已验证

  • dart analyze 0 告警、dart test 19 个用例全绿(用 fake_async 虚拟时钟,不 sleep)
  • 完整工程已打包:打包下载
本章目录 · 16 节

5.1 本章目标

  • 理解 Dart 的并发模型:单线程事件循环 + 微任务队列,没有 goroutine 那种"并行";
  • 把 Future 用对:await/then、Future.wait/any、超时、错误传播;
  • 分清 Future(一个值) 与 Stream(一串值),会用 async*/yield、StreamController、背压与取消;
  • 知道"未捕获的异步错误会让整个 isolate 崩溃"意味着什么;
  • 会用 fake_async 写确定性的异步测试(不 sleep、不依赖真实时钟)。

对照 Go:Future ≈ 一次异步调用的句柄;Stream ≈ channel;但 Dart 没有"并行",只有"交错"。真正的并行要用 isolate(ch08),而 isolate 之间不共享内存。

5.2 事件循环:微任务队列优先于事件队列

Dart 每个 isolate 有两条队列:

队列 放什么 例子
微任务(microtask) 当前任务结束后立刻执行,插队 scheduleMicrotask、Future.microtask、await 的续体
事件(event) 下一次循环再执行,FIFO Timer、Future(...)、I/O 完成、Stream 事件

规则:每跑完一个事件,就把微任务队列全部排空,再取下一个事件。

dartlib/futures.dart源文件
// examples/ch05-async/lib/futures.dart
Future<List<String>> scheduledOrder() async {
  final log = <String>[];
  log.add('sync-1');
  scheduleMicrotask(() => log.add('microtask'));
  Timer(Duration.zero, () => log.add('timer'));
  unawaited(Future<void>(() => log.add('future')));
  unawaited(Future<void>.microtask(() => log.add('future.microtask')));
  log.add('sync-2');
  await Future<void>.delayed(Duration.zero);
  await Future<void>.delayed(Duration.zero);
  return log;
}

真实输出(dart run):

text
[sync-1, sync-2, microtask, future.microtask, timer, future]

三个反直觉的点:

  1. 同步代码先跑完(sync-1、sync-2 在任何异步任务之前);
  2. 微任务按入队顺序跑:scheduleMicrotask 早于 Future.microtask;
  3. Future(...) 不是微任务——它是 Timer.run 的语法糖,进的是事件队列,而且因为它是在 Timer(Duration.zero) 之后注册的,所以排在 timer 后面。

这条顺序是理解 await 的基础:await 之后的代码本质上是一个微任务续体。所以"await 之后世界可能已经变了"——这就是 ch06 里必须检查 mounted 的原因。

5.3 Future:一个将来会有值的句柄

dart
Future<int> fetchValue(int x) =>
    Future<int>.delayed(const Duration(milliseconds: 100), () => x * 2);

三条心法:

  1. Future 不是线程。创建它只是"安排一个将来会执行的回调",代码还是在当前 isolate 的线程上跑。
  2. await 不阻塞线程,只把当前函数的后半段包成回调(编译器重写成状态机),让出事件循环给别的任务。
  3. async 函数总是返回 Future,即使你 return 42(会被包成 Future.value(42));抛异常会变成"失败的 Future",而不是同步抛出。

串行 vs 并发

dart
Future<int> sumSequential() async {
  final a = await fetchValue(1);   // 100ms
  final b = await fetchValue(2);   // +100ms
  final c = await fetchValue(3);   // +100ms
  return a + b + c;
}

Future<int> sumConcurrent() async {
  final results = await Future.wait<int>([fetchValue(1), fetchValue(2), fetchValue(3)]);
  return results.reduce((a, b) => a + b);
}

实测(dart run 的真实耗时):

text
串行结果: 12  耗时: 308ms
并发结果: 12  耗时: 103ms

这是 await 最重要的实践:await 一个接一个 = 串行;要并发就要先拿到 Future 列表,再 Future.wait。写作 Future.wait([f(), g()]) 时两个函数已经同时启动了。

组合器 语义 陷阱
Future.wait 等全部完成,返回结果列表 默认 eagerError: false:有错也等全部跑完再抛;eagerError: true:立刻抛,但其余 Future 不会被取消
Future.any 第一个完成的赢 其余继续跑,结果被丢弃
.timeout(d) 超时抛 TimeoutException 给了 onTimeout 就降级返回值
.catchError(f) 回调式兜错 只能兜它上游的错,链式顺序敏感

错误处理

dart
Future<int> failing() async {
  await Future<void>.delayed(const Duration(milliseconds: 10));
  throw StateError('后端返回 500');
}

Future<int> recovered() async {
  try {
    return await failing();
  } on StateError catch (e) {
    return e.message.length;        // 降级
  }
}
语言 异步错误怎么传
C 回调里带 err 参数 / 全局 errno / 信号——每条路径都要手工检查
Go error 返回值,每个 if err != nil 都要写
Dart 异常沿 await 链自动向上抛,try/catch 一次兜住

Dart 的写法更接近"零成本的 Go error":不用每步检查,但必须在某一层兜住。兜不住会怎样?

未捕获的异步异常会杀掉整个 isolate。fireAndForget 里如果 Future 失败又没人监听,runZonedGuarded/Flutter 的 FlutterError.onError 之外就没有兜底了,进程直接退出。这就是为什么 Dart 提供 unawaited():它不改变行为,只是显式声明"我知道这个 Future 没人 await"。

5.4 Stream:异步的序列

Stream<T> = 0..N 个 T 事件 + 可选错误 + 结束信号。对照表:

项 Go channel Dart Stream
传输 多个值,有缓冲/无缓冲 多个事件,带内部缓冲
生产 ch <- v yield v(async*)或 controller.add(v)
消费 for v := range ch await for (final v in s) 或 s.listen(...)
关闭 close(ch) controller.close() / 生成器返回
变换 手写 goroutine + 中间 channel .map().where().take(),纯同步包装,不建线程
多消费者 天然支持(每个值只被一个接收者拿到) 单订阅流只能一个 listener;broadcast() 才能多播(但每个 listener 都收到全量)
取消 ctx.Done() + select subscription.cancel()

生产:async* + yield

dart
Stream<int> countdown(int from) async* {
  for (var i = from; i > 0; i--) {
    await Future<void>.delayed(const Duration(milliseconds: 10));
    yield i;
  }
}

这比手写 StreamController 省事得多:yield 一个值就是一次事件,函数返回就是流结束,throw 就是错误事件。

sync* 是它的同步版,返回 Iterable:

dart
Iterable<int> fibSync(int n) sync* { /* yield a; */ }

变换是惰性的

dart
Stream<int> evenSquares(Stream<int> source) =>
    source.where((int x) => x.isEven).map((int x) => x * x);

where/map 只是包装,没有 listener 时什么都不会发生。测试里用计数器证明了这一点:没有监听时 produced == 0,监听后变成 4。这和 Go 的"goroutine 一启动就跑"完全不同——没有消费者,Dart 的流不会白跑。

消费:await for vs listen

方式 优点 限制
await for 写法像同步循环,错误直接 try/catch 迭代之间会 pause 订阅;无法中途 cancel 之外的控制
listen 有 onError/onDone,可 pause/resume/cancel 回调式,错误不会抛到你面前
dart
Future<List<int>> collect(Stream<int> stream) async {
  final out = <int>[];
  await for (final value in stream) {
    out.add(value);
  }
  return out;
}

必须取消订阅,这是 Dart 版的 free():

dart
final sub = ticker().listen((int v) { /* ... */ });
await sub.cancel();   // 不取消 → 定时器/Socket/监听器永远活着,闭包也被 GC 钉住

在 Flutter 里这条规则变成:initState 里订阅,dispose 里必须取消(ch06)。漏掉就是内存泄漏 + "setState called after dispose"。

StreamController 与生命周期钩子

dart
controller = StreamController<int>(
  onListen: () => log.add('listen'),
  onCancel: () => log.add('cancel'),
  onPause: () => log.add('pause'),
  onResume: () => log.add('resume'),
);

四个钩子对应订阅者的四种动作,是资源管理的唯一正确位置:onListen 里启动底层资源(打开文件、订阅 Socket),onCancel 里释放。

实测日志:[listen, cancel]。

单订阅 vs 广播

类型 特点
默认(单订阅) 只能有一个 listener;事件在无人监听时缓冲(有背压)
.broadcast() 多个 listener 各收全量;不缓冲,新 listener 收不到历史事件

单订阅流第二个 listener 会直接抛 StateError: Stream has already been listened to.——示例里有断言。

5.5 背压(backpressure)

StreamSubscription.pause() 会让上游停止推送。示例用一个 20ms 周期的 ticker 演示:

dart
Future<List<int>> collectWithPause(Stream<int> stream) async {
  final out = <int>[];
  final sub = stream.listen(out.add);
  await Future<void>.delayed(const Duration(milliseconds: 25));
  sub.pause();
  await Future<void>.delayed(const Duration(milliseconds: 100));
  sub.resume();
  // ...
}

dart run 的真实输出:

text
pause 期间不累积: [0, 1, 2, 3, 4]

Go 里对应 make(chan int, 1) 的阻塞语义:消费者慢,生产者就卡住。Dart 单订阅流也是如此——事件在缓冲区里等,不会丢。

Stream.periodic 的特殊行为:onPause 会取消定时器、onResume 重建。可暂停/可丢事件是这个实现决定的,不是所有流都这样。

5.6 用 fake_async 写确定性测试

异步测试最忌讳 await Future.delayed(Duration(seconds: 2)):测试变慢且不稳定。package:fake_async 提供虚拟时钟:

dart
test('Future.wait 并发,耗时 = 最慢的那个', () {
  fakeAsync((FakeAsync async) {
    int? result;
    unawaited(sumConcurrent().then((int v) => result = v));

    async.elapse(const Duration(milliseconds: 100));
    expect(result, 12);       // 三个 100ms 并发 → 只过了 100ms
  });
});

测试里还断言了两个精确时刻:

dart
// eagerError: false → 等所有任务(30ms)结束才抛
expect(lazyTime, const Duration(milliseconds: 30));
// eagerError: true → 第二项在 20ms 失败,立刻抛
expect(eagerTime, const Duration(milliseconds: 20));

只要时间够长,fake_async 会让定时器瞬间"快进"——真实耗时是 0ms。

实测踩坑:await for 消费 Stream.periodic 在 fake_async 下收不到任何事件。原因是 await for 在两次迭代之间暂停订阅,而 Stream.periodic 的 onPause 会取消定时器、onResume 重建,这条"虚拟时钟 + 定时器重建"的链在 fake_async 里不推进。真实运行时完全正常(dart run 输出 ticker().take(3): [0, 1, 2]),所以那个用例改成了 listen。 遇到这种"虚拟时钟不推进"的情况,优先怀疑 Timer.periodic + pause 的组合。

5.7 运行与验证

bash
cd examples/ch05-async
dart pub get && dart analyze && dart test && dart run

dart run 真实输出(节选):

text
--- 1. 串行 vs 并发 ---
串行结果: 12  耗时: 308ms
并发结果: 12  耗时: 103ms

--- 2. 事件循环顺序 ---
[sync-1, sync-2, microtask, future.microtask, timer, future]

--- 4. 超时 ---
给了 onTimeout: -1
超时异常: TimeoutException

--- 5. Stream ---
倒计时: [5, 4, 3, 2, 1]
偶数的平方: [36, 16, 4]
ticker().take(3): [0, 1, 2]

--- 6. 订阅与取消 ---
取消前收到 2 个,取消后仍是 2 个

--- 7. StreamController ---
controller 生命周期日志: [listen, cancel]

附:C/Go 代码对照:并发取三个值

go
// Go:goroutine 真并行,WaitGroup 等齐
func fetchAll() []int {
    results := make([]int, 3)
    var wg sync.WaitGroup
    for i := range results {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            results[i] = fetch(i + 1)   // 三个 goroutine 可同时跑在不同核上
        }(i)
    }
    wg.Wait()
    return results
}
dart
// Dart:Future.wait 并发"交错",只在单线程上轮流推进
Future<List<int>> fetchAll() => Future.wait<int>([
      fetchValue(1),
      fetchValue(2),
      fetchValue(3),
    ]);
Go Dart
并行 ✅ 多核 ❌ 单 isolate 内只有一个线程
取消 context Future 不可取消;Stream 靠 cancel
共享状态 需要 mutex/atomic 没有共享,所以没有锁

真并行要把任务丢进 Isolate.run(ch08);对 I/O 密集任务,Dart 的单线程事件循环已经够用。

5.8 本章小结 + C/Go 对照清单

主题 C Go Dart 陷阱
并发单位 pthread / epoll goroutine(真并行) 无;只有事件循环 Dart 里 await 不等于开线程
并行 线程 + 锁 goroutine + GOMAXPROCS isolate(ch08),不共享内存 没有 Mutex 需求,也没有数据竞争
一次性异步结果 回调 + err 参数 channel 接收一次 / error Future<T> 忘了 await → 变成 fire-and-forget
多个异步结果 回调 + 链表 channel Stream<T> 忘了 cancel → 泄漏
错误传播 返回值/errno error 返回值逐层检查 异常沿 await 链自动上抛 未捕获 → isolate 崩
同步原语 pthread_mutex sync.Mutex 不需要(单线程) 唯一的共享是 isolate 之间的消息
取消 pthread_cancel(不可靠) context.Context subscription.cancel() Future 不可取消,只能丢弃结果
背压 手动 无缓冲 channel 单订阅流缓冲 广播流没有背压

给 C/Go 老兵的三句话:

  1. Future 是"句柄"不是"线程";await 是语法糖,让你用同步写法写回调链。
  2. 要并发就用 Future.wait,别连写三个 await——这是性能差异最大的一行代码。
  3. Stream 用完必须 cancel,Future 不可取消(只能不理它的结果)——这和 Go 的 context 有本质区别。

下一章回到 Flutter:StatefulWidget、setState、生命周期。你会看到本章的 Future/Stream 被塞进 initState/dispose 之后,产生了 Flutter 里最经典的三个 bug:setState() called after dispose()、泄漏的订阅、以及在 build 里发起异步请求。