Dart 异步:Future、async/await、Stream、异步错误处理
第 5 章 · Dart 异步:Future、async/await、Stream、异步错误处理
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 事件 |
规则:每跑完一个事件,就把微任务队列全部排空,再取下一个事件。
// 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):
[sync-1, sync-2, microtask, future.microtask, timer, future]
三个反直觉的点:
- 同步代码先跑完(
sync-1、sync-2在任何异步任务之前); - 微任务按入队顺序跑:
scheduleMicrotask早于Future.microtask; Future(...)不是微任务——它是Timer.run的语法糖,进的是事件队列,而且因为它是在Timer(Duration.zero)之后注册的,所以排在timer后面。
这条顺序是理解
await的基础:await之后的代码本质上是一个微任务续体。所以"await之后世界可能已经变了"——这就是 ch06 里必须检查mounted的原因。
5.3 Future:一个将来会有值的句柄
Future<int> fetchValue(int x) =>
Future<int>.delayed(const Duration(milliseconds: 100), () => x * 2);
三条心法:
Future不是线程。创建它只是"安排一个将来会执行的回调",代码还是在当前 isolate 的线程上跑。await不阻塞线程,只把当前函数的后半段包成回调(编译器重写成状态机),让出事件循环给别的任务。async函数总是返回Future,即使你return 42(会被包成Future.value(42));抛异常会变成"失败的 Future",而不是同步抛出。
串行 vs 并发
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 的真实耗时):
串行结果: 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) |
回调式兜错 | 只能兜它上游的错,链式顺序敏感 |
错误处理
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
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:
Iterable<int> fibSync(int n) sync* { /* yield a; */ }
变换是惰性的
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 |
回调式,错误不会抛到你面前 |
Future<List<int>> collect(Stream<int> stream) async {
final out = <int>[];
await for (final value in stream) {
out.add(value);
}
return out;
}
必须取消订阅,这是 Dart 版的 free():
final sub = ticker().listen((int v) { /* ... */ });
await sub.cancel(); // 不取消 → 定时器/Socket/监听器永远活着,闭包也被 GC 钉住
在 Flutter 里这条规则变成:initState 里订阅,dispose 里必须取消(ch06)。漏掉就是内存泄漏 + "setState called after dispose"。
StreamController 与生命周期钩子
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 演示:
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 的真实输出:
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 提供虚拟时钟:
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
});
});
测试里还断言了两个精确时刻:
// 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 运行与验证
cd examples/ch05-async
dart pub get && dart analyze && dart test && dart run
dart run 真实输出(节选):
--- 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: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: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 老兵的三句话:
Future是"句柄"不是"线程";await是语法糖,让你用同步写法写回调链。- 要并发就用
Future.wait,别连写三个await——这是性能差异最大的一行代码。 Stream用完必须cancel,Future不可取消(只能不理它的结果)——这和 Go 的context有本质区别。
下一章回到 Flutter:StatefulWidget、setState、生命周期。你会看到本章的 Future/Stream 被塞进 initState/dispose 之后,产生了 Flutter 里最经典的三个 bug:setState() called after dispose()、泄漏的订阅、以及在 build 里发起异步请求。