一个查询接口要同时查两个数据源,每个查询各花一秒,接口总耗时却是三秒。代码写得很整齐:先 await 第一个,再 await 第二个。看起来没问题,实际上是串行等待,第二个查询非要等第一个完成才开始。两个操作互不依赖,完全可以同时进行。
这是 async/await 最常见的误用:把异步写成了「换个姿势的同步」。await 的作用是「等待这个操作完成,期间不占线程」,不是「立刻开始下一个操作」。要并发,得先把两个任务都启动起来,再一起等待。另一个极端是到处 .Result,把异步又拽回同步,轻则变慢,重则死锁。
这篇讲 C# 异步编程的核心:async 方法在编译器里变成了什么、await 前后发生了什么、异常和取消怎么处理、Task.WhenAll 和 Parallel.For 各适合什么场景、async void 为什么危险。示例在本机 .NET 8 控制台项目里跑过,输出照实贴出。异步和 I/O 在操作系统层面的关系,可以回看 IO 模型那一篇。
先看串行和并发的真实差距
下面这段代码定义了一个异步方法,延迟指定毫秒后返回编号乘十。主程序先串行等待两个,再用 Task.WhenAll 同时等待三个,最后演示取消和并行循环:
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static async Task<int> Work(int id, int ms)
{
await Task.Delay(ms);
return id * 10;
}
static async Task Main()
{
var sw = Stopwatch.StartNew();
var a = await Work(1, 300);
var b = await Work(2, 300);
sw.Stop();
Console.WriteLine($"sequential: {a + b} in {sw.ElapsedMilliseconds} ms");
sw.Restart();
var results = await Task.WhenAll(Work(1, 300), Work(2, 300), Work(3, 300));
sw.Stop();
Console.WriteLine($"whenall: {string.Join(",", results)} in {sw.ElapsedMilliseconds} ms");
using var cts = new CancellationTokenSource(200);
try
{
await Task.Delay(1000, cts.Token);
}
catch (OperationCanceledException ex)
{
Console.WriteLine("cancel: " + ex.GetType().Name);
}
var sum = 0;
Parallel.For(1, 101, i => Interlocked.Add(ref sum, i));
Console.WriteLine("parallel sum: " + sum);
}
}
本机 dotnet run 输出:
sequential: 30 in 619 ms
whenall: 10,20,30 in 313 ms
cancel: TaskCanceledException
parallel sum: 5050
两次 300 毫秒的等待串行执行,总耗时 619 毫秒;三个 300 毫秒的等待同时进行,总耗时 313 毫秒。后者不是「三个操作变快了」,而是它们重叠在了一起。定时器的精度和系统调度会让数字略有偏差,但「串行相加」和「取最大值」的差别非常明显。
取消那一段用了一个 200 毫秒后自动触发的令牌,等待 1000 毫秒的任务被取消,抛出 TaskCanceledException。它继承自 OperationCanceledException,捕获时按后者处理更通用。并行求和从 1 加到 100 得到 5050,用 Interlocked.Add 保证多线程累加不丢结果。
数字里有一点要解释:串行版本是 619 毫秒,不是精确的 600。定时器的触发精度、线程调度、程序启动开销都会叠加进来。异步耗时测试不要追求毫秒级精确,关注「串行相加」和「并发取最大」这个结构性差别就够了。
async 和 await 在编译器里变成了什么
标了 async 的方法,编译器会把它改写成一个小型状态机。方法执行到第一个 await 时,如果等待的任务还没完成,它会先返回一个未完成的 Task 给调用方,把后续代码注册成回调,等任务完成后再继续。线程在这期间被释放,可以去干别的活。
如果任务已经完成,await 不会挂起,直接同步往下走。这就是为什么「异步方法里没有真正的异步操作」时,它可能完全同步执行。编译器会警告「此异步方法缺少 await 运算符」,不是强迫你加,而是提醒你这个方法名不副实。
返回值类型通常是 Task 或 Task<T>,也可以用 ValueTask 减少分配,但它有使用限制,普通业务代码优先用 Task。async void 只应该出现在事件处理器里,因为它没法被等待,异常也没法传给调用方。
还有一个隐藏细节:await 默认会捕获当前的同步上下文,任务完成后回到原来的上下文继续执行。这在有单线程上下文的环境里很重要,但也会带来开销。类库代码通常加 ConfigureAwait(false),表示「不需要回到原上下文」,业务层则要看具体场景,不要无脑加也不要无脑不加。
异步方法里的局部变量会被提升到状态机对象里,跨 await 保持状态。这意味着一个长生命周期的 async 方法持有的大对象,可能比预期活得更久。方法里不要不必要地保存大缓冲区,用完及时释放,别让状态机替你「记住」它们。
为什么不能同步等待异步
看到 .Result 或 .Wait(),就应该把它当成潜在的死锁点。它们会阻塞当前线程,直到任务完成。在有单线程同步上下文的环境里,任务完成后的后续代码需要回到这个线程,而线程正被阻塞着,两边互相等待,程序就卡住。
// 仅用于说明问题,未在本机实测
var data = client.GetStringAsync(url).Result;
控制台程序没有单线程上下文,所以这段代码通常只是阻塞,不会立刻死锁,但会白白占住一个线程。线程池的线程有限,阻塞多了就饥饿,其他异步任务排队等不到线程,表现为整体变慢。这个问题在上一篇文章里已经展开过,这里只强调结论:异步要一路 async 到底。
Task.Run 包裹 .Result 来「修复」死锁。那只是把阻塞挪到另一个线程,线程池照样被占。真正的修复是把调用链上的方法都改成 async,让 await 一路传上去,入口处再等。如果确实被困在同步接口里,无法改签名,至少用 GetAwaiter().GetResult() 而不是 .Result,后者会把异常包成 AggregateException,堆栈也更难读。但这只是缓解症状,不解决线程被占的问题。
判断自己的代码有没有这个问题,可以搜三个关键词:.Result、.Wait()、GetAwaiter().GetResult()。前两个尽量清零,第三个只在确实无法改签名的边界处保留,并加上注释说明原因。不要因为「本地跑着没死」就放过它们,环境一换就可能出问题。
异常:await 会抛出什么
await 一个失败的 Task 时,异常会在 await 的位置抛出,类型是任务内部的实际异常,不是 AggregateException。这让异步代码的异常处理和同步代码接近,可以直接用 try/catch 包住。
用 Task.WhenAll 等待多个任务时,只要有一个失败,await 就会抛出异常,但抛出的是第一个失败的异常,其他任务的异常也在 Task 里,需要额外查看。任务不会因为一个失败就自动取消其他任务,它们会继续跑完。需要「一个失败就全部停」时,要用取消令牌联动。
try
{
await Task.WhenAll(task1, task2, task3);
}
catch (Exception ex)
{
Console.WriteLine(ex.GetType().Name);
foreach (var t in new[] { task1, task2, task3 })
if (t.IsFaulted) Console.WriteLine(t.Exception?.InnerException?.Message);
}
这段代码先捕获第一个异常,再逐个检查哪个任务失败了、具体原因是什么。只捕获不检查,会漏掉其他任务的错误。生产代码里应该把失败的任务和异常都记录下来,而不是只打印一行「出错了」。
取消异常和真实失败要分开处理。取消通常意味着调用方不再需要结果,不应该记成错误,也不应该触发告警;真实失败才需要告警和重试。可以在 catch 里先判断 ex is OperationCanceledException,再看令牌是否已取消,避免把正常的取消刷成错误日志。
取消与并发:令牌、WhenAll 和 Parallel.For
CancellationToken 是协作式取消,不是强制终止。你传一个令牌给异步操作,操作在合适的检查点发现令牌已取消,就主动抛出 OperationCanceledException。没有检查点的操作不会因为令牌取消就立刻停下。
令牌要从入口一路传到最底层。常见错误是中间某一层新建了一个 CancellationTokenSource,或者干脆没把令牌传下去,导致外层取消了,底层还在跑。正确的做法是方法签名统一带一个 CancellationToken 参数,调用时原样传递,不要重新创建。
超时可以用 CancellationTokenSource(TimeSpan) 实现,也可以在调用处用 CancelAfter。取消和超时在异常类型上很接近,都是 OperationCanceledException,所以捕获后要判断令牌状态,区分「用户取消」和「超时」。不要把所有取消都当成失败,有些取消是正常的业务结束。
default,这样不想取消的调用方可以忽略它。库代码在每次可能耗时的操作前调用 ThrowIfCancellationRequested,让取消及时生效。不要在取消后继续做清理之外的工作。取消之外,另一个常被问的问题是「怎么让多个操作同时进行」。下面这几个工具解决的是并发组织,和取消是两件事,可以配合使用。
Task.WhenAll 等待所有任务完成,适合「多个独立操作都要结果」的场景,比如同时查三个数据源再合并。Task.WhenAny 等待第一个完成的任务,适合「谁先回来用谁」或者自己做超时竞速。
var completed = await Task.WhenAny(task1, Task.Delay(TimeSpan.FromSeconds(2)));
if (completed != task1) Console.WriteLine("timeout");
这段代码在两秒内等 task1,等不到就打印超时。注意 Task.Delay 的任务也会完成,所以要用返回值判断到底是哪个先完成。超时后别忘了取消或处理原来的任务,否则它可能继续在后台跑。
Parallel.For 和 Parallel.ForEach 是数据并行,把一批 CPU 密集型工作分到多个线程上执行。它们适合计算量小、数量多、彼此独立的循环,不适合 I/O 等待。I/O 密集的并发应该用 Task.WhenAll 加异步 API,而不是 Parallel.For 里做同步阻塞。
| 需求 | 适合的工具 | 注意点 |
|---|---|---|
| 多个独立 I/O 同时进行 | Task.WhenAll | 先把任务都创建出来,再统一等待,不要逐个 await |
| 谁先完成就用谁 | Task.WhenAny | 判断返回值是哪个任务,超时后处理剩余任务 |
| 一批 CPU 计算分到多核 | Parallel.For | 循环体不要做 I/O,共享状态要加锁或原子操作 |
| 限制同时执行的数量 | SemaphoreSlim | 等待信号量也要异步,避免阻塞线程池线程 |
需要限制并发度时,用 SemaphoreSlim.WaitAsync 控制同时进入的数量。不要一次创建几千个任务,线程池和下游服务都承受不了。批量处理时按批提交,或者用生产者消费者的方式控制节奏。
var gate = new SemaphoreSlim(4);
var tasks = urls.Select(async url =>
{
await gate.WaitAsync();
try { return await client.GetStringAsync(url); }
finally { gate.Release(); }
});
var all = await Task.WhenAll(tasks);
这段代码同时最多有四个请求在跑,其余的在等信号量。等待信号量本身也是异步的,不会占住线程。注意 Release 要放在 finally 里,异常路径也要归还名额,否则并发度会越用越小。
async void 和即发即忘为什么危险
async void 方法不能被 await,调用方启动它之后立刻返回,根本不知道它什么时候完成、是否成功。方法内部抛出的异常没有地方传播,通常会导致进程崩溃,或者被全局处理器吞掉,日志里只剩一条不明所以的记录。
// 仅用于说明问题,未在本机实测
async void FireAndForget()
{
await Task.Delay(10);
throw new InvalidOperationException("boom");
}
调用 FireAndForget() 的地方没法 try/catch 到这个异常,因为它不在调用栈上。唯一合理的 async void 场景是事件处理器,因为事件签名要求返回 void。即便如此,也应该在方法内部包一层 try/catch,把异常记录下来,不要让它们逃出去。
「即发即忘」的 Task 也一样危险:_ = SomeAsync() 看起来是故意丢弃,但异常会留在 Task 里,直到被垃圾回收时才可能触发未观察异常。正确做法是保留 Task 并等待,或者显式包裹 try/catch 处理失败,或者交给一个统一的后台任务管理器。
如果必须在后台启动一个不等待的任务,至少给它包一层异常处理,并把失败记录下来。不要指望全局异常处理器兜底,它拿不到完整的调用上下文,日志里往往只有一句「未处理的异常」,排查时等于没有线索。
真实项目里的现象与排查方向
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 接口耗时等于几个操作之和 | 多个独立的 await 串行执行 | 先创建所有任务,再用 Task.WhenAll 统一等待 |
| 程序卡死,线程堆栈停在 .Result | 同步等待异步,单线程上下文互相等 | 搜 .Result 和 .Wait(),改成 await |
| 异步接口越压越慢,线程数上涨 | 线程池饥饿,阻塞调用占满线程 | 检查是否有同步 I/O 或 Thread.Sleep 混在异步链路里 |
| 取消了但后台还在跑 | 令牌没有一路传到底层,或底层没有检查点 | 检查方法签名和调用链,确认令牌是否原样传递 |
| 只捕获到一个异常,其他错误丢了 | Task.WhenAll 只抛第一个异常 | 遍历所有任务的 IsFaulted 和 Exception |
| 进程莫名退出,日志没有异常 | async void 或即发即忘的任务异常没有被观察 | 搜 async void 和未等待的 Task,加全局异常记录 |
| Parallel.For 里 CPU 不高但很慢 | 循环体里做了同步 I/O,线程都在等 | 把 I/O 改成异步,或改用 WhenAll 并发 |
| 超时判断不准 | WhenAny 返回的是延迟任务,但代码没判断是哪个 | 比较返回值,超时后取消原任务 |
排查异步问题时,先看「哪些操作本来可以并行,却被写成了串行」,再看「哪里把异步又同步化了」,最后看「异常和取消有没有被正确处理」。这三类问题覆盖了大多数线上表现。
边界与代价
- async 不是免费的:状态机、Task 分配、上下文切换都有开销。极短的操作直接用同步代码更划算,不要为了「看起来异步」而异步。
- 并发不等于并行:异步 I/O 并发是在等待时重叠,不占额外线程;CPU 并行才需要多核。把两者混为一谈,容易写出占满线程池的代码。
- 取消是协作式的:底层不检查令牌,取消就不会生效。第三方库如果不支持取消,只能等它自己结束,或者用超时放弃。
- WhenAll 不会自动停止其他任务:一个失败,其他继续跑。需要「全停」时,自己用令牌联动,别指望 WhenAll。
- ConfigureAwait 要按层决定:类库通常不需要回到原上下文,业务层可能需要。无脑加或完全不加都可能出问题,理解自己的上下文再决定。
- 并发度要受控:一次创建几千个任务,线程池和下游都受不了。用信号量、分批或队列控制节奏。
- 耗时测试要关掉调试开销:Debug 配置下 JIT 优化和运行时检查都会影响结果,测异步耗时至少用 Release,并且多跑几轮取中间值。
最后一个原则:异步的目标是「不浪费等待时间」,不是「让所有代码都变成 async」。I/O 等待适合异步,CPU 计算适合并行,简单同步操作保持同步。先判断操作性质,再选工具。
当天能自己验证的练习
以下练习都在一个控制台项目里完成,改 Program.cs 后执行 dotnet run:
- 把本文的串行等待改成先创建两个任务再
Task.WhenAll,对比耗时,确认从「相加」变成「取最大值」。 - 给一个延迟任务传 200 毫秒的 CancellationTokenSource,捕获异常并打印类型,再判断令牌是否已取消。
- 用
Task.WhenAny让一个 1 秒任务和一个 2 秒延迟竞速,打印哪个先完成;再把延迟改成 3 秒,观察超时分支。 - 用
Parallel.For求和 1 到 100,循环体里用Interlocked.Add,确认结果是 5050;再把累加改成普通sum += i,多跑几次观察结果是否出错。 - 写一个 async void 方法,内部延迟后抛异常,在调用处用 try/catch 包住,确认捕获不到;再改成返回 Task 并用 await,确认能正常捕获。
小结
三句话收一下:await 是「等待且不占线程」,不是「立刻执行下一步」,多个独立操作要先启动再 WhenAll;异步要一路 async 到底,不要用 .Result 把线程卡住;取消靠令牌一路传递,异常要逐个任务检查,async void 和即发即忘要尽量避免。
到这里,C# 这一组从类型、语言特性、集合、文件、网络、进程、线程到异步,基本把语言和运行时的主干走了一遍。下一步可以挑一个方向深入:性能分析、内存管理,或者用这些基础去读真实项目的代码。先把每一篇的练习跑一遍,比继续看新概念更有用。