w wyl123ly 的博客
MD

CSharp-05-异步编程

46 KB 2026.10.11 原文件

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 三种返回类型:什么时候用哪个

返回类型调用方可以适用场景反例
Taskawait、等待、组合默认选择,无返回值—
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;
        }
    }
}

这解释了四个常见现象:

  1. async 方法在第一个未完成的 await 之前是同步执行的——调用方在这段时间内会被阻塞。
  2. 已经完成的任务(如缓存命中)走 IsCompleted == true 分支,全程无分配、无线程切换。
  3. 异常在 GetResult() 处抛出,所以 try/catch 要包在 await 外层,而不是包在方法调用外层。
  4. 每次挂起都要分配状态机与续体(值类型状态机在首次挂起时被装箱到堆上)。

4.2 await 前后的线程切换

static async Task ShowSwitching()
{
    Console.WriteLine($"调用线程: {Environment.CurrentManagedThreadId}");
    await Task.Delay(10);
    Console.WriteLine($"续体线程: {Environment.CurrentManagedThreadId}");
}
是否存在 SynchronizationContext / TaskSchedulerawait 恢复位置
有(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 Corenull续体在线程池任意线程;.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()AggregateExceptionagg.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("程序继续运行,异常没有让进程崩溃");

机制如下:

  1. 任务异常被记录在 Task.Exception 上,状态变为 Faulted。
  2. 如果这个 Task 从未被 await/Wait/读取 Exception,它就是未观察的(unobserved)。
  3. 该任务被 GC 回收时,运行时触发 TaskScheduler.UnobservedTaskException 事件。
  4. .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());
}

死锁的四步链条:

  1. UI 线程执行到 .Result,阻塞等待 GetDataAsync() 完成。
  2. GetDataAsync 内部 await Task.Delay(1000) 完成,续体被 SynchronizationContext 投递到 UI 线程的消息队列。
  3. 但 UI 线程正卡在 .Result 上,没有在跑消息循环,无法执行那个续体。
  4. 续体不执行 → 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>
消费语法foreachawait 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:async Lambda 传给 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 计算时,异步没有优势。


十八、小结

你要做的事正确写法
等待 IOawait 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 模型对照阅读

参考来源