CSharp-05-异步编程
这篇讲什么
异步编程解决的核心问题不是"更快",而是在等待 IO 时不要占着线程。一个线程约 1 MB 栈、一次上下文切换要几微秒,而一次数据库查询要几毫秒——阻塞式等待把这两者的量级差距变成了吞吐瓶颈。
本篇按"代价 → 抽象 → 机制 → 陷阱 → 组合 → 取消"推进,重点讲清四件事:
Task是承诺而不是线程、死锁是怎么被.Result造出来的、未 await 的异常会被静默吞掉、CancellationToken是协作式的。阅读前提:CSharp-04-委托事件与Lambda(
async void与事件处理器、Lambda 与闭包)。示例以 .NET 10 / C# 14 为基准。
一、是什么:从"阻塞等待"到"回调承诺"
同步代码在等待 IO 时,线程什么也不做但也不让出:
// 同步版本:线程在这 200ms 内被完全占用,不能服务其他请求
public static string FetchSync()
{
Thread.Sleep(200); // 模拟网络/磁盘等待
return "data";
}
异步版本把"等待"这件事交给操作系统与运行时,线程立刻返回线程池去干别的活:
public static async Task<string> FetchAsync()
{
await Task.Delay(200); // 线程被释放,200ms 后由续体继续
return "data";
}
Task<string> 是一个承诺(promise):现在还没有字符串,但将来会有,或者会失败,或者会被取消。它由三种终态之一结束:
二、为什么需要它:同步阻塞的真实代价
2.1 线程是稀缺资源
| 资源 | 典型成本 |
|---|---|
| 一个托管线程的栈 | 约 1 MB 虚拟内存(默认提交量小得多) |
| 线程创建 | 数十到数百微秒 |
| 上下文切换 | 约 1–5 微秒,外加缓存失效 |
| 一次数据库查询 | 约 1–50 毫秒 |
| 一次跨机房 HTTP 调用 | 约 50–500 毫秒 |
一次 50ms 的数据库调用期间,如果线程被阻塞,它错过的可运行时间相当于上万次上下文切换的量级。
2.2 同步 vs 异步:数值对照
假设每个请求要等 3 次各 100ms 的 IO,CPU 计算总耗时约 1ms:
| 指标 | 同步阻塞 | 异步(async/await) |
|---|---|---|
| 单请求墙上时间 | 约 301 ms | 约 301 ms |
| 单请求占用线程时间 | 约 301 ms | 约 1 ms |
| 并发 1000 个请求所需线程 | 约 1000 个 | 约 1–几十个 |
| 内存(仅线程栈) | 约 1 GB 虚拟内存 | 约几十 MB |
| 线程池排队/饥饿风险 | 高(默认最小线程数增长很慢) | 低 |
| 单位时间吞吐 | 受线程数上限压制 | 受 IO 与下游容量限制 |
关键结论
异步不会让单个请求变快,它提升的是并发能力与资源利用率。
如果你的场景是纯 CPU 计算(如矩阵乘法、图像压缩),异步毫无帮助——那需要的是并行(
Task.Run+ 多核),见下文 7.3。
2.3 为什么线程池的"增长慢"是致命的
.NET 线程池为每秒注入新线程的数量设了上限(典型值约每秒 1–2 个)。当 1000 个请求同时阻塞时,线程池不会瞬间给你 1000 个线程,于是新请求排队,延迟雪崩式上升——这就是线程池饥饿(thread pool starvation)。
三、Task 与 Task<T> 的本质
3.1 承诺,而不是线程
| 常见误解 | 事实 |
|---|---|
Task 就是一根线程 | Task 是一个状态机 + 续体列表;Task.Run 才会用到线程池线程 |
await 会新建线程 | await 通常不创建任何线程;完成时在线程池已有线程上继续 |
await 会让当前线程阻塞 | await 让当前线程返回到调用方(或线程池) |
没有 Task.Run 就不算异步 | IO 型异步由操作系统 IOCP/epoll 驱动,本就无需线程 |
// 这个 Task 完全没有线程参与:它只是把 Timer 包装成承诺
static async Task NoThreadExample()
{
Console.WriteLine($"await 前,线程 {Environment.CurrentManagedThreadId}");
await Task.Delay(50);
Console.WriteLine($"await 后,线程 {Environment.CurrentManagedThreadId}");
// 两行的线程号可能相同(续体被调度回同一线程池线程),也可能不同
}
3.2 Task 家族对照
| 类型 | 用途 | 是否有返回值 | 备注 |
|---|---|---|---|
Task | 无返回值的异步操作 | 无 | 不能 await 两次(第二次仍会完成,但语义混乱) |
Task<T> | 有返回值的异步操作 | 有 | 结果缓存在 Result 中,可多次读取 |
ValueTask / ValueTask<T> | 常常同步完成的异步操作 | 可选 | 是 struct,避免分配;只能 await 一次 |
TaskCompletionSource<T> | 手工控制 Task 完成时机 | 有 | 把回调式 API 桥接成 Task |
IAsyncEnumerable<T> | 异步流(多个值) | 多个值 | 用 await foreach 消费 |
Task.Yield() | 主动让出 | 无 | 强制异步点,常用于 UI 让出 |
// 把回调式(EAP)API 桥接为 Task —— TaskCompletionSource 的标准用法
public static Task<string> DownloadAsTaskAsync(string url)
{
var tcs = new TaskCompletionSource<string>(
TaskCreationOptions.RunContinuationsAsynchronously); // 防止续体同步执行导致栈增长
var client = new HttpClient();
client.GetAsync(url).ContinueWith(t =>
{
if (t.IsFaulted) tcs.TrySetException(t.Exception!.InnerExceptions);
else if (t.IsCanceled) tcs.TrySetCanceled();
else tcs.TrySetResult(t.Result.StatusCode.ToString());
client.Dispose();
}, TaskScheduler.Default);
return tcs.Task;
}
为什么
RunContinuationsAsynchronously几乎是必备项默认情况下
TrySetResult会同步执行所有等待者的续体。如果续体里有耗时或阻塞逻辑,TrySetResult的调用点就被拖住了;更糟的是可能形成极深的同步调用链。加上这个选项后,续体改为投递到线程池执行。
3.3 三种返回类型:什么时候用哪个
| 返回类型 | 调用方可以 | 适用场景 | 反例 |
|---|---|---|---|
Task | await、等待、组合 | 默认选择,无返回值 | — |
Task<T> | await 取 T | 默认选择,有返回值 | — |
async void | 什么都不能 | 仅事件处理器 | 除了事件处理器一律禁止 |
ValueTask<T> | await(一次) | 热路径且常同步完成 | 需要 WhenAll、需要缓存复用 |
四、async/await 的执行流程
4.1 编译器改写:状态机
async 方法被编译器改写为一个状态机结构体(实现 IAsyncStateMachine),它记录了"执行到哪一步":
public static async Task<int> ComputeAsync(int seed)
{
int a = seed + 1; // 状态 0 之前:同步执行
await Task.Delay(10); // 状态 0:可能挂起
int b = a * 2; // 状态 1:续体恢复后执行
await Task.Delay(10); // 状态 1:可能再次挂起
return b + 3; // 状态 2:设置结果
}
改写后的形状(概念示意):
// 编译器实际生成的东西(极度简化)
private struct ComputeAsyncStateMachine : IAsyncStateMachine
{
public int State; // -1 = 运行中,-2 = 已完成
public AsyncTaskMethodBuilder<int> Builder;
private int _seed, _a, _b;
private TaskAwaiter _awaiter;
public void MoveNext()
{
switch (State)
{
case 0: _a = _seed + 1; goto case 1;
case 1:
_awaiter = Task.Delay(10).GetAwaiter();
if (!_awaiter.IsCompleted) // 关键分支:没完成才真的"异步"
{
State = 2;
Builder.AwaitUnsafeOnCompleted(ref _awaiter, ref this);
return; // ← 方法在此返回,线程被释放
}
goto case 2;
case 2:
_awaiter.GetResult(); // ← 异常在这一行抛出
_b = _a * 2;
// …再 await 一次
Builder.SetResult(_b + 3);
break;
}
}
}
这解释了四个常见现象:
async方法在第一个未完成的await之前是同步执行的——调用方在这段时间内会被阻塞。- 已经完成的任务(如缓存命中)走
IsCompleted == true分支,全程无分配、无线程切换。 - 异常在
GetResult()处抛出,所以try/catch要包在await外层,而不是包在方法调用外层。 - 每次挂起都要分配状态机与续体(值类型状态机在首次挂起时被装箱到堆上)。
4.2 await 前后的线程切换
static async Task ShowSwitching()
{
Console.WriteLine($"调用线程: {Environment.CurrentManagedThreadId}");
await Task.Delay(10);
Console.WriteLine($"续体线程: {Environment.CurrentManagedThreadId}");
}
是否存在 SynchronizationContext / TaskScheduler | await 恢复位置 |
|---|---|
| 有(WPF/WinForms 的 UI 上下文、经典 ASP.NET) | 捕获并投递回该上下文(保证回到 UI 线程) |
无(控制台、ASP.NET Core、Task.Run 内部) | 投递到线程池,任意可用线程 |
显式写了 ConfigureAwait(false) | 忽略上下文,直接用线程池 |
4.3 SynchronizationContext 的作用
SynchronizationContext 抽象了"把一段代码送回原环境执行"的能力:
// WPF 里:Post 会通过 Dispatcher 把回调排到 UI 线程的消息队列
// 伪代码说明其行为,实际由框架提供实例
SynchronizationContext? ctx = SynchronizationContext.Current;
ctx?.Post(state => Console.WriteLine($"回到 UI 线程: {Environment.CurrentManagedThreadId}"),
null);
| 环境 | SynchronizationContext.Current | 后果 |
|---|---|---|
| WPF / WinForms | 非 null(Dispatcher / WindowsForms 上下文) | 续体回到 UI 线程,可以直接更新控件 |
| 经典 ASP.NET(.NET Framework) | 非 null(AspNetSynchronizationContext) | 续体回到请求上下文;.Result 会死锁 |
| ASP.NET Core | null | 续体在线程池任意线程;.Result 不会死锁但有线程饥饿风险 |
| 控制台 | null | 同上 |
Task.Run 内部 | null(上下文不流动到线程池) | 同上 |
五、异常传播
5.1 await 与 Wait() 抛出的异常类型不同
static async Task<int> AlwaysFailsAsync()
{
await Task.Delay(1);
throw new InvalidOperationException("业务失败");
}
// 路径 A:await —— 抛出原始异常,堆栈被"清洗"到 await 点
try
{
await AlwaysFailsAsync();
}
catch (InvalidOperationException ex)
{
Console.WriteLine($"await 捕获: {ex.GetType().Name}"); // InvalidOperationException
}
// 路径 B:.Result / .Wait() —— 包一层 AggregateException
Task<int> t = AlwaysFailsAsync();
try
{
_ = t.Result;
}
catch (AggregateException agg)
{
Console.WriteLine($"Result 捕获: {agg.GetType().Name}, 内层 {agg.InnerExceptions.Count} 个");
Console.WriteLine($"内层类型: {agg.InnerException!.GetType().Name}");
}
| 等待方式 | 抛出的异常 | 内层异常访问 |
|---|---|---|
await task | 原始异常(自动解包第一个) | 直接 catch (InvalidOperationException) |
task.Result / task.Wait() | AggregateException | agg.InnerExceptions 或 agg.Flatten() |
task.GetAwaiter().GetResult() | 原始异常(与 await 一致) | 直接捕获 |
AggregateException的由来
Task设计于并行库(TPL)时代,一个任务可能派生多个子任务并同时失败,因此需要一个能承载多个异常的容器。而
await的语义是"把这一个任务的结果取出来",所以它解包并抛出第一个异常。多个异常可以在Task.Exception.InnerExceptions里看到(Task.WhenAll场景下尤其常见)。
5.2 多个异常:Task.WhenAll 的坑
var tasks = new[]
{
Task.FromException(new InvalidOperationException("A")),
Task.FromException(new ArgumentException("B")),
Task.FromException(new FormatException("C")),
};
// 关键:先把 WhenAll 的 Task 存下来,异常信息挂在"这一个" Task 上
Task all = Task.WhenAll(tasks);
try
{
await all;
}
catch (Exception ex)
{
Console.WriteLine($"await 只抛出第一个: {ex.GetType().Name}"); // InvalidOperationException
// 想看全部异常,必须回到 WhenAll 返回的那个 Task 上取 Exception
AggregateException agg = all.Exception!;
Console.WriteLine($"真实异常总数: {agg.InnerExceptions.Count}"); // 3
foreach (var inner in agg.Flatten().InnerExceptions)
Console.WriteLine($" - {inner.GetType().Name}: {inner.Message}");
}
5.3 未 await 的任务:异常被静默吞掉
static void FireAndForget()
{
// 没有 await,也没有保存 Task 引用 → 异常无人观察
Task.Run(() => throw new InvalidOperationException("没人看得到我"));
}
FireAndForget();
Thread.Sleep(200);
Console.WriteLine("程序继续运行,异常没有让进程崩溃");
机制如下:
- 任务异常被记录在
Task.Exception上,状态变为Faulted。 - 如果这个
Task从未被await/Wait/读取Exception,它就是未观察的(unobserved)。 - 该任务被 GC 回收时,运行时触发
TaskScheduler.UnobservedTaskException事件。 - .NET 4.5 起,该事件若无人处理,进程不会崩溃(.NET 4.0 会终止进程)。这是一次为兼容性做的重大行为变更。
// 全局兜底:把被吞掉的异常记录下来,至少能发现问题
TaskScheduler.UnobservedTaskException += (sender, e) =>
{
Console.WriteLine($"[未观察的任务异常] {e.Exception.Flatten().InnerExceptions.Count} 个");
foreach (var ex in e.Exception.Flatten().InnerExceptions)
Console.WriteLine($" - {ex.GetType().Name}: {ex.Message}");
e.SetObserved(); // 标记为已观察,避免升级处理
};
GC.Collect();
GC.WaitForPendingFinalizers(); // 只有 GC 之后事件才会被触发
GC.Collect();
不要用这个事件做业务兜底
UnobservedTaskException的触发时机取决于 GC,可能几秒后才来,也可能永远不来。它只适合做"最后的观测网 + 日志告警"。真正的做法是:永远不要丢弃返回的
Task。
六、async void 的危害
// 危险:调用方拿不到任何东西,无法 await、无法捕获
public static async void DangerousAsync()
{
await Task.Delay(10);
throw new InvalidOperationException("这个异常会直接跑到同步上下文上");
}
// 调用方以为包了 try/catch 就安全 —— 其实毫无作用
try
{
DangerousAsync(); // 方法在第一个 await 处就返回了
}
catch (Exception)
{
Console.WriteLine("永远不会执行到这里");
}
async void 的问题清单:
| 问题 | 后果 |
|---|---|
无法 await | 调用方无法知道它何时结束 |
| 无法组合 | 不能进 Task.WhenAll |
| 异常无法被调用方捕获 | 直接抛给 SynchronizationContext,在 UI 应用里通常崩溃进程 |
| 无法取消 | 没有 Task 可传 CancellationToken |
| 难以测试 | 测试无法等待其完成 |
唯一合理用途:事件处理器
事件的签名被
EventHandler固定为返回void,所以只能用async void。即使如此,也应该在方法内部用
try/catch包住整个方法体,绝不让异常逃逸:
private async void OnSaveClicked(object? sender, EventArgs e)
{
try
{
await SaveAsync(); // 正常异步逻辑
}
catch (OperationCanceledException)
{
// 用户主动取消,不算错误
}
catch (Exception ex)
{
// async void 的异常若逃逸,在 UI 应用里会直接终止进程
ShowError($"保存失败:{ex.Message}");
}
}
如果需要从事件处理器启动一个可跟踪的后台任务,标准做法是"async void 只做入口,立即转交 async Task":
private void OnSaveClicked(object? sender, EventArgs e) => _ = RunSafelyAsync(SaveAsync());
private static async Task RunSafelyAsync(Task work)
{
try { await work; }
catch (Exception ex) { Console.WriteLine($"后台任务异常: {ex.Message}"); }
}
七、死锁:复现与讲解
7.1 UI 场景的经典死锁(完整可复现)
这是一个真实的 WinForms 程序,运行后界面会永久卡死:
// 需要 <TargetFramework>net10.0-windows</TargetFramework> 与 UseWindowsForms=true
using System;
using System.Windows.Forms;
public sealed class DeadlockForm : Form
{
private readonly Button _button = new() { Text = "点我会卡死", Dock = DockStyle.Fill };
public DeadlockForm()
{
Controls.Add(_button);
_button.Click += OnButtonClick; // 事件处理器(唯一允许 async void 的地方)
}
// ★ 这就是问题所在:在 UI 线程上同步等待一个需要 UI 线程才能完成的异步操作
private async void OnButtonClick(object? sender, EventArgs e)
{
_button.Text = "处理中……";
string data = GetDataAsync().Result; // ← 死锁发生在这行
_button.Text = data;
}
private static async Task<string> GetDataAsync()
{
await Task.Delay(1000); // 1 秒后需要"回到 UI 线程"才能继续
return "完成";
}
[STAThread]
public static void Main() => Application.Run(new DeadlockForm());
}
死锁的四步链条:
- UI 线程执行到
.Result,阻塞等待GetDataAsync()完成。 GetDataAsync内部await Task.Delay(1000)完成,续体被SynchronizationContext投递到 UI 线程的消息队列。- 但 UI 线程正卡在
.Result上,没有在跑消息循环,无法执行那个续体。 - 续体不执行 →
Task永不完成 →.Result永不返回。互等,永久死锁。
在经典 ASP.NET(.NET Framework)里形状完全一样,只是把"UI 线程"换成"请求线程 + AspNetSynchronizationContext"。
ASP.NET Core 为什么不会这样死锁
ASP.NET Core 没有
SynchronizationContext(SynchronizationContext.Current为null),续体直接投递到线程池,因此不依赖"请求线程空闲"。但
.Result仍然有害:它占住一根线程池线程,高并发下会触发线程池饥饿,表现为吞吐骤降、请求超时。仍是反模式。
7.2 三种解法
解法一:一路 async 到底(首选)
private async void OnButtonClick(object? sender, EventArgs e)
{
try
{
_button.Text = "处理中……";
string data = await GetDataAsync(); // 不阻塞,让出 UI 线程
_button.Text = data;
}
catch (Exception ex)
{
_button.Text = $"出错:{ex.Message}";
}
}
解法二:ConfigureAwait(false) 切断上下文(仅限库代码)
// 库内部不关心线程亲和性,用 ConfigureAwait(false) 避免"必须回到 UI 线程"
private static async Task<string> GetDataAsync()
{
await Task.Delay(1000).ConfigureAwait(false); // 续体在线程池执行
return "完成";
}
// 现在下面这行"不会"死锁了 —— 但仍然不该这么写!
// string data = GetDataAsync().Result;
解法二只是"绕过"死锁,不是"解决"问题
.Result依然阻塞线程,只是恰好不再需要 UI 线程了。一旦库内部任何一处漏写ConfigureAwait(false),死锁立刻回归。所以它不是可依赖的方案。
解法三:把阻塞代码挪到线程池,再异步等待
private async void OnButtonClick(object? sender, EventArgs e)
{
// Task.Run 把同步工作搬到线程池,UI 线程用 await 等待而不是阻塞
string data = await Task.Run(() => LegacyBlockingCall());
_button.Text = data;
}
private static string LegacyBlockingCall()
{
// 这里可以放心用 .Result,因为运行在线程池线程上,没有 UI 上下文
return GetDataAsync().ConfigureAwait(false).GetAwaiter().GetResult();
}
| 解法 | 是否根治 | 适用场景 | 代价 |
|---|---|---|---|
| 一路 async 到底 | 是 | 所有能改签名的代码 | 需要改调用链签名 |
ConfigureAwait(false) | 否(缓解) | 类库内部 | 漏一处就复发 |
Task.Run + await | 是(隔离) | 第三方同步 API 无法修改 | 多占一根线程池线程 |
GetAwaiter().GetResult() | 否 | 极端场景(Main 方法、测试夹具) | 仍阻塞,只是异常不被包装 |
八、ConfigureAwait(false) 的作用与时机
// 有上下文时:await 默认捕获并回到原上下文
await DoIoAsync(); // 等价于 ConfigureAwait(true)
// 无上下文需求时:明确表示"我不在乎在哪个线程继续"
await DoIoAsync().ConfigureAwait(false);
| 使用位置 | 建议 | 理由 |
|---|---|---|
| 类库 / NuGet 包 | 每个 await 都加 ConfigureAwait(false) | 不假设宿主环境,避免上下文切换开销与死锁风险 |
| 应用层(UI 事件处理器) | 不加 | 下一行要更新控件,需要回到 UI 线程 |
| ASP.NET Core 控制器 | 可加可不加 | 没有 SynchronizationContext,加上可省一点开销 |
await foreach / await using | 用 .ConfigureAwait(false) 扩展形式 | 需要在 foreach/using 上加 |
两条经验法则
1. 库代码一律
ConfigureAwait(false):它让库"对宿主上下文无感",这是微软官方 FAQ 的核心建议。2. 加了
ConfigureAwait(false)之后,其后的代码可能运行在线程池线程上,因此不要再访问 UI 控件、HttpContext(经典 ASP.NET)、DbContext等有线程亲和性或作用域要求的对象。
九、并发组合
9.1 Task.WhenAll / Task.WhenAny
static async Task<string> FetchAsync(string name, int ms)
{
await Task.Delay(ms);
return $"{name}({ms}ms)";
}
// 顺序 await:总耗时 = 各任务之和
var sw = System.Diagnostics.Stopwatch.StartNew();
await FetchAsync("A", 300);
await FetchAsync("B", 300);
Console.WriteLine($"顺序: {sw.ElapsedMilliseconds} ms"); // 约 600 ms
// WhenAll:并发启动,总耗时 = 最慢的那个
sw.Restart();
Task<string> ta = FetchAsync("A", 300);
Task<string> tb = FetchAsync("B", 300);
string[] results = await Task.WhenAll(ta, tb); // 关键:先拿到 Task 再 await
Console.WriteLine($"并发: {sw.ElapsedMilliseconds} ms → {string.Join(",", results)}"); // 约 300 ms
// WhenAny:谁先完成用谁,典型用途是"超时"
sw.Restart();
Task<string> fast = FetchAsync("慢", 5000);
Task timeout = Task.Delay(300);
Task winner = await Task.WhenAny(fast, timeout);
if (winner == timeout)
Console.WriteLine("超时了,不再等待");
else
Console.WriteLine($"结果: {await fast}");
循环里逐个 await 是隐形的性能杀手
```csharp
// 错误:总耗时 = 所有请求之和
foreach (var url in urls) results.Add(await FetchAsync(url));
```
正确做法是先把所有任务启动起来,再统一等待:
```csharp
// 正确:总耗时 ≈ 最慢的那个
Task<string>[] tasks = urls.Select(u => FetchAsync(u)).ToArray();
string[] all = await Task.WhenAll(tasks);
```
注意:只有当你确实要"并发"时才这样写。如果下游服务承受不了并发压力,逐个 await 反而是正确的(顺序限流)。
9.2 Task.Delay 与 Thread.Sleep 的区别
| 对比项 | Thread.Sleep(1000) | await Task.Delay(1000) |
|---|---|---|
| 线程占用 | 阻塞当前线程 1 秒 | 释放线程,1 秒后调度续体 |
| 可取消 | 不能 | Task.Delay(1000, ct) |
| 适用位置 | 同步代码、测试、后台线程 | 异步代码(几乎总是选它) |
| 精度 | 与系统时钟相关(约 15.6 ms 粒度) | 同上 |
| 在 UI 线程上使用 | 冻结界面 | 界面正常响应 |
| 大量并发使用 | 线程池饥饿 | 一个定时器即可支撑成千上万个 |
9.3 Task.Run 的适用边界
| 工作负载 | 该怎么做 | 为什么 |
|---|---|---|
| IO 密集(HTTP、数据库、文件) | 直接用异步 API,不要 Task.Run | 异步 API 内部用 IOCP,无需线程;Task.Run 白白多占一根线程池线程 |
| CPU 密集(计算、压缩、加密) | await Task.Run(() => Compute()) | 计算必须占 CPU,搬到线程池可让 UI 保持响应 |
| 已有同步 API,无异步版本 | await Task.Run(() => LegacySync()) | 隔离阻塞,是权宜之计 |
| ASP.NET Core 服务器端 | 不要 Task.Run 包 IO 操作 | 服务器已在线程池上,多一次切换只增加开销 |
// 反例:服务器端的无意义 Task.Run
public async Task<IActionResult> GetBad()
{
// Task.Run 只是把同一份工作从一根线程池线程搬到另一根
var data = await Task.Run(() => _httpClient.GetStringAsync("https://example.com"));
return Ok(data);
}
// 正例:直接 await
public async Task<IActionResult> GetGood()
{
var data = await _httpClient.GetStringAsync("https://example.com");
return Ok(data);
}
十、CancellationToken 协作式取消
CancellationToken 不是强制中断:它只是一个信号。被调用方必须主动检查并自行退出,这就是"协作式"的含义。
using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
public static class CancellationDemo
{
public static async Task RunAsync()
{
// 1) 3 秒后自动取消 —— 也可用 CancelAfter 之外的 Cancel()/CancelAsync()
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
CancellationToken token = cts.Token;
try
{
string result = await DownloadAsync("https://example.com", token);
Console.WriteLine($"成功:{result.Length} 字符");
}
catch (OperationCanceledException ex) when (ex.CancellationToken == token)
{
// 区分"我方取消"与"网络异常",when 过滤是关键
Console.WriteLine("已按预期取消");
}
}
private static async Task<string> DownloadAsync(string url, CancellationToken ct)
{
using var client = new HttpClient();
// 2) 把 token 一路传下去:HttpClient 内部会监听它并中断 IO
string text = await client.GetStringAsync(url, ct).ConfigureAwait(false);
// 3) 纯 CPU 的循环必须手工检查,否则永远无法取消
int count = 0;
foreach (char c in text)
{
ct.ThrowIfCancellationRequested(); // 抛 OperationCanceledException
if (c == 'a') count++;
}
// 4) 也可以在"返回成功值"与"取消"之间做选择
if (count == 0)
ct.ThrowIfCancellationRequested(); // 幂等:未取消时不抛
return $"字符 a 出现 {count} 次";
}
}
| API | 用途 |
|---|---|
CancellationTokenSource.Cancel() | 立即请求取消(同步,会就地执行已注册的回调) |
CancellationTokenSource.CancelAfter(ms / TimeSpan) | 到期自动取消 |
CancellationTokenSource.CancelAsync() | 请求取消并等待回调完成(.NET 8+) |
token.IsCancellationRequested | 查询状态,用于"能优雅收尾"的场景 |
token.ThrowIfCancellationRequested() | 抛 OperationCanceledException,最简单 |
token.Register(callback) | 注册清理回调(如关闭连接、释放资源) |
Task.Delay(ms, token) | 可取消的延时 |
Task.WaitAsync(token) | 给任意任务加一层超时/取消(.NET 6+) |
取消相关的三个易错点
1. 不要吞掉
OperationCanceledException后返回默认值——调用方会以为操作成功完成,得到一份空数据。让异常继续传播。2.
TaskCanceledException是OperationCanceledException的子类。catch (OperationCanceledException)会同时捕获两者;TaskCanceledException常见于HttpClient超时。3.
CancellationTokenSource必须Dispose(用using)。它内部注册了定时器与回调链,不释放会造成泄漏。
十一、IAsyncEnumerable<T> 与 await foreach
普通 Task<T> 只能返回一个结果;异步流可以边产生边消费,避免把所有结果先攒进内存:
// 生产者:每 200ms 产出一个数字,3 个后结束
public static async IAsyncEnumerable<int> ProduceAsync(
[System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken ct = default)
{
for (int i = 1; i <= 3; i++)
{
await Task.Delay(200, ct).ConfigureAwait(false);
yield return i * 10; // yield return 出现在 async 方法里
}
}
// 消费者
public static async Task ConsumeAsync()
{
await foreach (int value in ProduceAsync().WithCancellation(CancellationToken.None))
{
Console.WriteLine($"收到 {value}"); // 每 200ms 打印一次,无需先攒满
}
}
// LINQ 风格:需要 System.Linq.Async 包(Microsoft 官方扩展)
// await foreach (int v in ProduceAsync().WhereAwait(...).ConfigureAwait(false)) { }
| 对比项 | IEnumerable<T> | IAsyncEnumerable<T> |
|---|---|---|
| 消费语法 | foreach | await foreach |
| 每次取值的代价 | 同步,可阻塞 | 异步,ValueTask<bool> MoveNextAsync() |
| 取消支持 | 无内建 | 可传 CancellationToken |
| 适用场景 | 内存集合、文件逐行读 | 数据库流式查询、分页拉取、实时推送 |
| EF Core 支持 | ToListAsync 一次性 | AsAsyncEnumerable() 流式读取 |
什么时候值得用异步流
数据量大到不想一次性全部加载(如导出百万行)、或者结果是"随时间陆续到达"的(如订阅推送、日志跟随)。
数据只有几十条时,
Task<List<T>>更简单也更快——异步流每次MoveNextAsync都有状态机开销。
十二、SemaphoreSlim 限制并发数
Task.WhenAll 会把所有任务同时启动,几百个请求可能压垮下游。SemaphoreSlim 是异步友好的限流原语:
public static async Task LimitConcurrencyAsync(IEnumerable<string> urls)
{
// 最多 4 个并发;注意 SemaphoreSlim 实现了 IDisposable
using var gate = new SemaphoreSlim(initialCount: 4, maxCount: 4);
using var client = new HttpClient();
var tasks = urls.Select(async url =>
{
await gate.WaitAsync().ConfigureAwait(false); // 用 WaitAsync 而非 Wait!
try
{
string body = await client.GetStringAsync(url).ConfigureAwait(false);
Console.WriteLine($"{url} → {body.Length} 字符");
}
finally
{
gate.Release(); // 必须放在 finally,异常也要归还许可
}
});
await Task.WhenAll(tasks);
}
三个细节
1. 一定要用
WaitAsync()。用同步的Wait()会阻塞线程池线程,把限流变成新的阻塞源。2.
Release()必须在finally里,否则一次异常就永久泄漏一个许可,最终整个流程僵死。3.
SemaphoreSlim有Dispose;长期存活的对象应被释放,短命对象用using。另外,如果只是想限制并行度而不是"资源的许可",.NET 6+ 还有更简洁的
Parallel.ForEachAsync:```csharp
using var sharedClient = new HttpClient(); // 复用连接,避免端口耗尽
await Parallel.ForEachAsync(urls, new ParallelOptions { MaxDegreeOfParallelism = 4 },
async (url, ct) =>
{
// 注意:把 HttpClient.GetStringAsync 的字符串重载赋给显式类型的委托,
// 否则与 GetStringAsync(HttpRequestMessage, ...) 重载产生歧义(CS0121)
Func<string, CancellationToken, Task<string>> fetch = sharedClient.GetStringAsync;
string body = await fetch(url, ct);
Console.WriteLine($"{url} → {body.Length} 字符");
});
```
Parallel.ForEachAsync在首个异常发生时会取消其余尚未开始的任务,这与Task.WhenAll的"等全部结束"语义不同。
十三、ValueTask 简介
ValueTask<T> 是值类型的 Task,避免"结果已经同步就绪"时的堆分配:
private static readonly Dictionary<int, string> Cache = new();
// 缓存命中时同步完成,不分配 Task 对象
public static ValueTask<string> GetCachedAsync(int id)
{
if (Cache.TryGetValue(id, out string? cached))
return new ValueTask<string>(cached); // 零分配路径
return new ValueTask<string>(LoadSlowAsync(id)); // 未命中才包装 Task
}
private static async Task<string> LoadSlowAsync(int id)
{
await Task.Delay(100);
string value = $"value-{id}";
Cache[id] = value;
return value;
}
| 对比项 | Task<T> | ValueTask<T> |
|---|---|---|
| 类型 | 引用类型(class) | 值类型(struct) |
| 同步完成路径 | 需分配/复用缓存 Task | 零分配 |
| 可否 await 多次 | 可以 | 不可以(未定义行为) |
可否 WhenAll / 缓存 | 可以 | 不可以 |
Result 属性 | 有(阻塞) | 有(未完成则抛异常) |
| 适用场景 | 默认选择 | 高频调用且多数同步完成的热路径 |
| 正确用法 | 随意 | 只 await 一次,不保存、不共享 |
ValueTask的误用后果```csharp
ValueTask<int> vt = GetValueAsync();
int a = await vt;
int b = await vt; // ✗ 未定义行为:可能抛异常、可能得到错误结果
Task<int> t = GetValueAsync().AsTask(); // 若确实需要复用,先转成 Task(会有分配)
```
经验法则:除非你能用基准测试证明
Task的分配是瓶颈,否则一律用Task。
十四、异步反模式清单
| 反模式 | 为什么错 | 正确做法 |
|---|---|---|
.Result / .Wait() | 阻塞线程;有上下文时死锁;异常被包成 AggregateException | 一路 async 到底 |
async void | 异常无法捕获,可能崩溃进程;无法等待 | 返回 Task;只有事件处理器例外 |
不传 CancellationToken | 用户关页面/请求超时后,后台仍白干活到结束 | 每个异步 API 都接收并向下传递 token |
循环里逐个 await | 总耗时是所有请求之和 | 先启动全部任务,再 Task.WhenAll |
Task.Run 包 IO | 白白多占一根线程池线程 | 直接用异步 IO API |
Task.Run 包 async Lambda 的两层包装 | Task.Run(async () => await X()) 在服务器端冗余 | 去掉 Task.Run |
catch (Exception) { } 吞掉取消异常 | 调用方以为成功,拿到空结果 | 让 OperationCanceledException 传播 |
库代码不写 ConfigureAwait(false) | 宿主上下文切换开销 + 潜在死锁 | 库内每个 await 都加 |
Task.Delay 代替真正的异步 | 只是假装异步,业务逻辑还是同步的 | 用真正可 await 的 IO API |
忘记 Dispose 的 CancellationTokenSource / SemaphoreSlim | 定时器与回调链泄漏 | using |
在 finally 之外 Release() | 一次异常就泄漏许可 | 放 finally |
用 Thread.Sleep 在异步方法里 | 阻塞线程池线程 | await Task.Delay |
十五、常见坑
坑 1:
async方法在第一个await之前是同步的如果
await前的代码耗时很长(比如同步读了一个大文件),调用方会被阻塞。应当在方法入口就await Task.Yield()或把同步部分拆出去。
坑 2:
using包在await外层并不能延长对象寿命```csharp
// 危险:using 在方法返回时就 Dispose 了,但后台任务还在用它
public Task<string> Bad()
{
using var client = new HttpClient();
return client.GetStringAsync("https://example.com"); // 返回的 Task 还在跑
}
```
正确写法是把
using与await放在同一个方法体内,或者使用IAsyncDisposable+await using。
坑 3:
Task.WhenAll在任一任务失败时行为
WhenAll会等到所有任务结束才抛异常,抛的是第一个异常。如果你希望"任一失败立刻放弃",用Task.WhenAny+ 手工检查,或Parallel.ForEachAsync(它在首个异常时会取消其余任务)。
坑 4:
ConfigureAwait(false)之后的代码不能碰 UI加了它之后,续体可能跑在线程池线程上,此时访问控件会抛
InvalidOperationException: 线程间操作无效。
坑 5:
CancellationToken的默认值陷阱
default(CancellationToken)是CancellationToken.None,永远不会取消、也无法取消。可选参数写成CancellationToken ct = default时,调用方忘记传就永远无法取消——设计 API 时最好要求必传。
坑 6:静态
CancellationTokenSource被取消后无法重用
CancellationTokenSource一旦取消就永久处于已取消状态。需要重复使用的场景应每次新建(或使用 .NET 8+ 的对象池模式),不要缓存一个用过的实例。
坑 7:
asyncLambda 传给Action会变成async void```csharp
list.ForEach(async x => await ProcessAsync(x)); // 实际是 async void!无法等待
```
想并发处理应显式收集任务:
await Task.WhenAll(list.Select(x => ProcessAsync(x)));
十六、练习题
练习 1(Task 的本质)
解释下面两段代码的差异,并说明哪一段更能体现"
Task不是线程"。```csharp
Task a = Task.Run(() => Thread.Sleep(1000));
Task b = Task.Delay(1000);
```
练习 2(异常传播)
给定
Task<int> t = FaultyAsync();,分别写出用t.Result、await t、t.GetAwaiter().GetResult()捕获异常时的catch类型,并解释差异来源。
练习 3(死锁分析)
下面代码在 WPF 里会死锁,在 ASP.NET Core 里不会。请分别说明原因,并给出两种修法(一种根治、一种缓解)。
```csharp
public string Get() => LoadAsync().Result;
private async Task<string> LoadAsync()
{
await Task.Delay(100);
return "ok";
}
```
练习 4(并发组合)
有 10 个 URL 要抓取,要求:(a) 总耗时尽量短;(b) 任意时刻最多 3 个并发请求;(c) 支持整体取消;(d) 单个失败不影响其他。
请写出完整实现,并说明为什么不能用
foreach + await,也不能无限并发。
练习 5(取消语义)
你写了一个
ReadAllAsync(stream, ct)。请说明:当ct在读取中途被触发时,这个方法应该抛什么异常?为什么不能"返回 null 表示取消"?调用方应如何区分"用户取消"和"真正的错误"?
练习 6(ValueTask 选型)
一个
ICache.GetAsync(string key)接口:95% 的调用命中内存缓存并同步返回。请说明是否应该返回ValueTask<T>,并列出使用ValueTask<T>时必须遵守的三条纪律。
十七、FAQ
FAQ 1:
await Task.Run(...)和直接await SomeAsync()有什么区别?
SomeAsync()是本来就是异步的操作(IO 由操作系统完成,不需要线程);Task.Run是把同步工作搬到线程池执行。IO 密集型操作套
Task.Run只会多消耗一根线程池线程,纯属浪费;CPU 密集型操作才需要Task.Run。
FAQ 2:
Task.Delay(0)有什么用?
Task.Delay(0)返回一个已完成的 Task,用它await几乎不产生异步切换(走IsCompleted == true分支)。想真正强制让出控制权,应该用
await Task.Yield()。想给 UI 一个重绘机会,两者都可,但Task.Yield语义更准确。
FAQ 3:为什么我的异步方法测试不稳定?
常见原因有三个:
1. 被测代码是
async void,测试无法等待;2. 测试方法本身是
async void而不是async Task(xUnit/NUnit 需要后者);3. 用了
Task.Delay做"等待"而不是等待真正的完成信号。另外,几乎不要用
Thread.Sleep做测试等待,它会让测试既慢又不稳。
FAQ 4:
SynchronizationContext和TaskScheduler是一回事吗?不是。
SynchronizationContext是更早的、更通用的"环境抽象"(UI 消息循环);TaskScheduler是 TPL 的调度抽象。
await优先使用SynchronizationContext.Current,为null时退化到TaskScheduler.Current,两者都为null时才用线程池。
FAQ 5:在
Main方法里怎么调用异步代码?C# 7.1+ 支持
static async Task Main(),直接写就行。若无法改签名,用SomeAsync().GetAwaiter().GetResult()——它至少不会把异常包成AggregateException。
FAQ 6:异步方法一定比同步快吗?
不。 单次调用上,异步有状态机与调度开销,可能比同步更慢。
收益出现在并发场景:异步让同样的线程数服务更多请求。只有一两个并发操作、或者纯粹 CPU 计算时,异步没有优势。
十八、小结
| 你要做的事 | 正确写法 |
|---|---|
| 等待 IO | await SomeIoAsync(ct),不加 Task.Run |
| 并行等待多个任务 | 先启动全部,再 await Task.WhenAll(tasks) |
| 只要最快的一个 | await Task.WhenAny(...),注意处理剩下的任务 |
| 执行 CPU 密集计算 | await Task.Run(() => Compute()) |
| 支持取消 | 一路传 CancellationToken,循环内 ThrowIfCancellationRequested() |
| 限制并发 | SemaphoreSlim.WaitAsync() + finally 中 Release() |
| 流式返回大量结果 | IAsyncEnumerable<T> + await foreach |
| 写类库 | 每个 await 加 ConfigureAwait(false) |
| 事件处理器 | async void + 方法体内完整 try/catch |
| 兜底观测丢失的异常 | TaskScheduler.UnobservedTaskException + 日志 |
相关笔记
- CSharp-04-委托事件与Lambda ——
async void与事件处理器的关系、TaskCompletionSource如何桥接回调式 API - CSharp-03-集合与LINQ ——
IAsyncEnumerable<T>与IEnumerable<T>的对照、EF Core 的异步查询 - 操作系统 —— 线程、上下文切换、线程池与 IO 多路复用的底层原理
- 后端-03-ASPNET-Core —— ASP.NET Core 为何没有
SynchronizationContext,以及请求管线中的异步实践 - JavaScript-04-异步编程 —— 事件循环与 Promise:与 C# 的
Task模型对照阅读
参考来源
- 使用 async 和 await 进行异步编程(Microsoft Learn,中文)
- 基于任务的异步模式(TAP)(Microsoft Learn,中文)
- 异步编程方案(Microsoft Learn,中文)
- 异步返回类型(Microsoft Learn,中文)
- 取消托管线程中的操作(Microsoft Learn,中文)
- Task.ConfigureAwait 方法(Microsoft Learn,中文)
- TaskScheduler.UnobservedTaskException 事件(Microsoft Learn,中文)
- SemaphoreSlim 类(Microsoft Learn,中文)
- IAsyncEnumerable<T> 接口(Microsoft Learn,中文)
- 生成和使用异步流(Microsoft Learn,中文)
- 在完成时处理多个异步任务(Microsoft Learn,中文)
- 按时间跨度取消异步任务(Microsoft Learn,中文)
- ConfigureAwait 常见问题(.NET 博客)
- .NET 5 中的 ValueTask 池化(.NET 博客)