罗罗编程学习记录
本页内容 展开查看

04.6.2.1 async/await 状态机与 Task

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.6 C# 与 .NET / 04.6.2 异步与并发

04.6.2.1-001 async/await 的实现原理是什么?

一句话结论

编译器把 async 方法改写为状态机:局部变量提升到状态机对象,遇到 await 挂起并注册续体,等待完成后从断点恢复继续执行。

概念解释

async 不是开线程,而是把方法拆成可暂停/恢复的状态转移。await 一个未完成的可等待对象时,方法返回已挂起的 Task;底层操作完成后,续体在合适上下文恢复状态机。

原理流程

  1. 编译器生成状态机类型,保存参数、局部变量与当前状态。
  2. 首个 await 未完成:注册完成回调,返回 Task。
  3. 等待完成:回调恢复状态机,从断点继续到结束,设置 Task 结果/异常。

代码或图示

async Task<string> FetchAsync() {
    var data = await http.GetStringAsync(url);
    return data;
}

常见误区

  • 以为 async 方法在新线程跑:IO 异步等待不占用线程;CPU 密集才需要调度到线程池。
  • 以为 await 阻塞当前线程:挂起释放线程,续体由完成回调恢复。

追问

  • 状态机保存哪些内容?答:方法参数、局部变量、await 点状态;闭包捕获变量同样被提升。
  • 同步完成的 await 会怎样?答:等待对象已完成时状态机继续同步执行,不挂起。

04.6.2.1-002 await 对可等待对象做了什么?

一句话结论

await 检查可等待者是否完成:未完成则订阅完成通知并挂起;已完成则直接取结果;完成后把结果或异常传回状态机。

概念解释

可等待者需提供 GetAwaiter(),实现 IsCompleted、OnCompleted 与 GetResult。Task 是最常见可等待对象;自定义可等待者用于特殊调度语义。

原理流程

  1. 调用 GetAwaiter 取等待者。
  2. IsCompleted 为 false:注册续体,返回挂起 Task。
  3. 完成后 OnCompleted 回调触发,GetResult 取结果或抛异常。

代码或图示

Task<int> task = ComputeAsync();
int value = await task;   // 等待者内部处理完成通知与结果提取

常见误区

  • 以为 await 直接阻塞线程:它注册回调,不占用等待线程。
  • 忽略等待者异常传播:未完成时异常在 await GetResult 处重新抛出。

追问

  • 自定义可等待者场景?答:需要自定义上下文调度、同步续体或特殊完成语义;日常业务用 Task/ValueTask。
  • 可等待者必须是 Task 吗?答:不是,满足等待者模式即可;Task 是 BCL 标准实现。

04.6.2.1-003 Task、Task 与 ValueTask 区别?

一句话结论

Task 代表无返回值异步操作,Task<T> 带结果;ValueTask 是值类型包装,用于高频已完成场景减少堆分配,但不可重复 await。

概念解释

Task 是引用类型,实例在堆上;ValueTask 可包装已完成结果或底层 Task,避免小结果异步路径的 Task 分配。ValueTask 设计为单次消费,重复 await/多次取结果有约束。

原理流程

  1. 异步 API 返回 Task/Task 描述操作与完成状态。
  2. ValueTask 在方法内判断是否已同步完成,直接携带结果。
  3. 调用方 await 后得到结果。

代码或图示

Task DoAsync();
Task<int> ReadAsync();
ValueTask<int> FastAsync();

常见误区

  • 把 ValueTask 存起来多次 await:ValueTask 不保证可重复消费,需要复用应 AsTask() 转 Task。
  • 以为 ValueTask 总是更快:已完成路径省分配;未完成路径仍包装 Task,按场景选择。

追问

  • ValueTask 何时用?答:库内部高频、常同步完成的 API;普通业务方法返回 Task 更简单。
  • Task 与线程对应吗?答:Task 是操作单元,不绑定单一线程;完成回调可在不同线程恢复。

04.6.2.1-004 为什么不建议 async void?

一句话结论

async void 没有返回 Task,调用方无法等待完成、无法观察异常;未捕获异常直接抛到同步上下文,可能导致进程崩溃。

概念解释

async void 仅适合事件处理器等无法返回 Task 的场景。业务方法应返回 Task/Task,让调用方等待、取消与处理异常。

原理流程

  1. void 异步方法不产出可等待 Task。
  2. 异常无法通过 Task 传播给调用方。
  3. 未捕获异常升级到同步上下文/进程级处理。

代码或图示

// 反例
async void Bad() { await WorkAsync(); }
// 正确
async Task Good() { await WorkAsync(); }

常见误区

  • 事件处理器写 async void 后内部吞异常:事件回调异常难以追踪,应在内部 try/catch 记录。
  • 把 async void 当 fire-and-forget:调用方完全失去生命周期与错误感知。

追问

  • fire-and-forget 怎么做更稳妥?答:返回 Task 由上层决定是否丢弃;内部捕获异常并记录,避免未观察异常。
  • async void 能被 await 吗?答:不能,无 Task 可等待。

04.6.2.1-005 Task 异常如何观察与传播?

一句话结论

异步方法异常被捕获存入 Task,await 时重新抛出;未观察的异常触发 UnobservedTaskException;应在链路末端 await 或显式 TryGetException 观察。

概念解释

Task 把异常包装为 AggregateException(多异常场景)。await 解包抛原始异常;未 await 且未读取 Exception 的 Task 异常在垃圾回收时被视为未观察。

原理流程

  1. 异步方法内异常写入 Task.Exception。
  2. await 时 GetResult 重新抛出。
  3. 未观察异常在 Task 终结时触发事件(默认策略依运行时版本,待确认)。

代码或图示

try { await DoAsync(); }
catch (HttpRequestException ex) { /* 记录 */ }

常见误区

  • 启动 Task 后不 await 也不处理:异常被遗漏,线上故障难定位。
  • 以为 AggregateException 一定出现:单异常 await 解包为原始异常;直接读 Exception 才见聚合包装。

追问

  • Task.Exception 与 IsFaulted?答:Faulted 表示出错,Exception 含聚合异常;访问属性即视为观察。
  • 后台任务异常记录在哪?答:内部 try/catch 写日志,或在链路末端统一观察;不要依赖未观察异常事件兜底。

04.6.2.1-006 ConfigureAwait(false) 做什么?

一句话结论

默认 await 捕获当前 SynchronizationContext 并在原上下文恢复;ConfigureAwait(false) 不要求回到原上下文,库代码可减少上下文开销与死锁风险。

概念解释

UI/传统 ASP.NET 有同步上下文,续体排队回原线程;库代码不依赖上下文时用 false 避免不必要封送。ASP.NET Core 无 SynchronizationContext,该配置影响较小。

原理流程

  1. await 时捕获上下文(默认)。
  2. ConfigureAwait(false) 跳过上下文捕获。
  3. 完成回调在线程池/可用线程恢复执行。

代码或图示

var data = await http.GetStringAsync(url).ConfigureAwait(false);

常见误区

  • 应用 UI 代码加 false 后访问控件:续体不在 UI 线程,跨线程更新界面出错。
  • 以为 ASP.NET Core 必须加 false:Core 无同步上下文,库代码加 false 是兼容性习惯。

追问

  • 什么场景经典死锁?答:UI/请求线程同步 .Result 等待 async 方法,续体排队回原上下文但原线程被阻塞。
  • 库与应用层策略?答:库代码优先 false;应用层按上下文需求决定,需要回 UI 线程用默认。

04.6.2.1-007 CancellationToken 如何传播取消?

一句话结论

CancellationToken 由 CancellationTokenSource 创建并传给异步链;取消时令牌标记已取消,协作式检查点退出操作,下游 API 感知并停止工作。

概念解释

取消是协作式:令牌只是信号,操作在可检查点观察令牌并抛出 OperationCanceledException。令牌可注册回调执行清理,链式调用一路透传。

原理流程

  1. 创建 CancellationTokenSource。
  2. 令牌传入异步方法与下游 API。
  3. 触发 Cancel:检查点抛取消异常,资源随 finally 清理。

代码或图示

using var cts = new CancellationTokenSource();
await FetchAsync(cts.Token);
// 需要时 cts.Cancel();

常见误区

  • 以为令牌能强制杀死操作:协作式取消,长循环必须主动检查令牌。
  • 取消异常被当错误吞掉:OperationCanceledException 应与业务错误区分处理。

追问

  • 令牌链接(LinkedTokenSource)?答:组合多个令牌,任一取消即触发;适合组合请求取消与超时。
  • 检查点在哪写?答:长循环/分段操作中 token.ThrowIfCancellationRequested(),下游 API 通常内置检查。

04.6.2.1-008 异步超时怎么实现?

一句话结论

用 CancellationTokenSource 延迟取消包装主操作,或 Task.WhenAny 等待任务与延时任务;超时后取消下游、清理资源并返回超时结果。

概念解释

超时不是自动中断:通过取消令牌通知协作式停止,或放弃等待但底层任务可能继续。需要真正停止工作必须把令牌传到可取消 API。

原理流程

  1. 创建带延迟的取消源。
  2. 主操作传入令牌。
  3. 超时触发取消;等待方判断谁先完成。

代码或图示

using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
try { await WorkAsync(cts.Token); }
catch (OperationCanceledException) { /* 超时/取消 */ }

常见误区

  • 只 WhenAny 超时不取消底层:任务继续占用资源,应配合令牌取消。
  • 超时后继续使用被放弃的 Task 结果:状态不确定,需明确处理。

追问

  • 延时取消与外部取消组合?答:CreateLinkedTokenSource 合并令牌,任一触发即取消。
  • 超时异常类型?答:OperationCanceledException(含 TimeoutException 派生关系,具体以 BCL 为准)。

04.6.2.1-009 Task 工厂方法与辅助 API?

一句话结论

Task.Run 把 CPU 工作调度到线程池;FromResult/FromException/FromCanceled 构造已完成 Task;WhenAll/WhenAny 组合多任务。

概念解释

Run 用于 CPU 密集工作排队;已完成 Task 用于接口返回与缓存路径。组合原语处理并发等待,注意异常在聚合中收集。

原理流程

  1. CPU 工作:Task.Run 排队线程池。
  2. 同步结果:FromResult 直接完成。
  3. 多任务:WhenAll 等全部,WhenAny 等首个。

代码或图示

var task = Task.Run(() => Compute());
var cached = Task.FromResult(42);
await Task.WhenAll(t1, t2);

常见误区

  • 用 Task.Run 包装 IO 异步 API:多余线程切换,IO 应直接 await 原生异步。
  • WhenAll 单任务失败即抛:其他任务仍在运行,需考虑取消与清理。

追问

  • Task.Factory.StartNew 与 Run 区别?答:Run 是简化封装,默认线程池调度;StartNew 可配置更多选项,误用较少。
  • 已完成 Task 复用?答:Task.CompletedTask 复用无结果完成任务,避免重复分配。

04.6.2.1-010 IAsyncEnumerable 流式异步怎么用?

一句话结论

IAsyncEnumerable<T> 表示异步产出的元素流,await foreach 逐个消费;适合分页、消息流、大结果集,避免一次性加载全部数据。

概念解释

异步枚举器在每个元素就绪时产出,消费方边收边处理。与同步 IEnumerable 对应,支持取消令牌与异步 MoveNext。

原理流程

  1. 生产方 yield return 产出异步流。
  2. 消费方 await foreach 逐个等待元素。
  3. 流结束或取消后清理资源。

代码或图示

async IAsyncEnumerable<Order> StreamAsync(CancellationToken ct) {
    foreach (var batch in batches) yield return batch;
}
await foreach (var o in StreamAsync(ct)) { }

常见误区

  • 把异步流先 ToList 物化:失去流式优势,大集合占内存。
  • 消费中途取消未传令牌:流无法及时停止。

追问

  • 异步流与 Channel 区别?答:IAsyncEnumerable 是拉取式枚举;Channel 是推送式队列,支持多生产多消费。
  • 异常在流中如何传播?答:枚举 MoveNext 时抛出,消费方在 await foreach 中捕获。

04.6.2.1-011 异步方法返回值有哪些约束?

一句话结论

async 方法可返回 Task、Task<T>、ValueTask、ValueTask<T>、void(仅事件)或 IAsyncEnumerable<T>;不能返回普通同步类型作为异步结果。

概念解释

返回类型必须是可等待/可枚举异步形态。返回 T 需包装为 Task;void 仅限事件处理器。编译器对返回类型有明确检查规则。

原理流程

  1. 声明异步返回类型。
  2. 方法内 return 值匹配 Task/ValueTask 结果类型。
  3. 编译器生成对应状态机与完成信号。

代码或图示

async Task<int> GetAsync() => 1;
async IAsyncEnumerable<int> GetStream();

常见误区

  • async 方法返回具体类型 T:编译错误,需 Task 包装。
  • 接口签名是 Task,实现返回 ValueTask:类型不兼容,需统一签名。

追问

  • 接口/抽象方法返回类型规则?答:签名必须一致;协变逆变对 Task 包装类型支持有限,以语言规则为准。
  • 构造函数能 async 吗?答:不能直接异步构造;用静态工厂异步方法创建实例。

04.6.2.1-012 await 如何捕获与恢复上下文?

一句话结论

await 时记录当前同步上下文/调度器;续体完成后把恢复回调封送回该上下文;无上下文时在线程池线程恢复。

概念解释

上下文决定续体执行位置:UI 上下文回 UI 线程,请求上下文回请求线程。捕获的是上下文引用,不是当前线程;ConfigureAwait 控制是否捕获。

原理流程

  1. 检查当前 SynchronizationContext。
  2. 有上下文:完成后 Post 续体回上下文。
  3. 无上下文:线程池调度恢复。

代码或图示

// UI 线程上
await LoadAsync();        // 续体回 UI 线程
await LoadAsync().ConfigureAwait(false); // 不回原上下文

常见误区

  • 以为续体一定在 await 所在线程恢复:取决于上下文调度,可能是线程池线程。
  • 上下文捕获导致嵌套死锁:同步等待 + 回原上下文组合易死锁。

追问

  • 同步上下文与调度器区别?答:SynchronizationContext 是高层封送抽象;TaskScheduler 控制 Task 调度,UI 上下文对应专用调度。
  • 上下文丢失后能恢复吗?答:捕获的引用决定恢复目标;离开上下文后不再自动回封。

04.6.2.1-013 同步等待 .Result/.Wait() 为什么危险?

一句话结论

在有同步上下文的线程上同步等待未完成 Task,续体排队回原线程而原线程被阻塞,形成循环等待死锁;还会把异步异常包成 AggregateException。

概念解释

经典场景:UI 按钮事件调 .Result,async 方法内部 await 后需回 UI 上下文,但 UI 线程卡在 Result 等待,续体无法执行。ASP.NET 传统上下文同理。

原理流程

  1. 原线程同步阻塞等待 Task。
  2. 异步操作完成,续体 Post 回原上下文。
  3. 原线程不可用,续体排队不执行,Task 永不完成。

代码或图示

// 反例(有上下文线程)
var result = FetchAsync().Result;

常见误区

  • 在库代码随意同步等待:破坏异步链,放大死锁与线程占用风险。
  • 以为所有 .Result 必死锁:无线程池上下文/任务已完成时不阻塞,但应避免依赖该假设。

追问

  • 必须同步桥接异步怎么办?答:尽量向上层改为异步;隔离线程池线程上等待可规避上下文死锁,但仍占用线程。
  • 异常包装差异?答:Wait/Result 抛 AggregateException;await 解包原始异常。

04.6.2.1-014 WhenAll 与 WhenAny 怎么组合并发?

一句话结论

WhenAll 等待全部任务完成(收集结果/聚合异常);WhenAny 等待首个完成,用于竞速、超时与流式处理;两者均不启动任务,只组合等待。

概念解释

并发度需另行控制(信号量/分批),WhenAll 只负责汇合。任一失败 WhenAll 尽快报错,但其余任务继续运行;WhenAny 可轮询已完成任务继续处理。

原理流程

  1. 启动多个异步任务。
  2. WhenAll 等待全部到达终态。
  3. WhenAny 任一完成即返回该任务。

代码或图示

var results = await Task.WhenAll(fetchA, fetchB, fetchC);
var first = await Task.WhenAny(t1, t2);

常见误区

  • 以为 WhenAll 限制并发:任务早已启动,并发度由启动方式决定。
  • WhenAll 失败后忽略其余任务:可能泄漏工作,需配合取消令牌。

追问

  • 结果类型收集?答:WhenAll<Task<T>[]> 返回 T[];无类型 Task[] 只等完成。
  • 部分失败处理?答:观察聚合异常,结合取消令牌停止未完成分支。

04.6.2.1-015 嵌套 Task 与解包?

一句话结论

Task<Task> 表示任务的任务,需两层 await 或 Unwrap();链式异步返回嵌套时,外层等待内层完成,避免把 Task 当结果返回。

概念解释

方法返回 Task.Run(async () => ...) 可能产生嵌套包装。await 对嵌套 Task 有解包规则;显式 Unwrap 把外层转为内层任务。

原理流程

  1. 内层任务被外层包装。
  2. 一次 await 得到内层 Task,需再 await 取结果。
  3. Unwrap 合并为单一任务链。

代码或图示

Task<Task<int>> nested = Task.Run(async () => InnerAsync());
Task<int> flat = nested.Unwrap();

常见误区

  • 把 Task<Task> 的内层 Task 当数值返回:类型错误,调用方拿到任务而非结果。
  • 嵌套导致异常/取消层级加深:解包后传播路径更清晰。

追问

  • await 解包规则?答:await 对 Task 自动取内层;具体规则以语言规范为准。
  • 何时产生嵌套?答:返回 Task.Run 包装异步 lambda、工厂方法未扁平化返回。

04.6.2.1-016 异步 Lambda 与局部函数?

一句话结论

async Lambda 可赋给 Func<Task> 委托;局部异步函数用于内部异步逻辑;二者同样生成状态机,注意捕获变量生命周期。

概念解释

异步 Lambda 常用于 Task.Run、事件回调与 LINQ 并发启动。局部函数可在方法内声明异步逻辑,复用且不污染外层作用域。

原理流程

  1. Lambda/局部函数标记 async。
  2. 编译为状态机委托/方法。
  3. 捕获外部变量被提升到闭包状态机。

代码或图示

Func<Task> work = async () => await DoAsync();
async Task LocalAsync() { await DoAsync(); }

常见误区

  • 异步 Lambda 返回 void:委托签名若为 Action 会变成 async void,应选 Func。
  • 闭包捕获大对象:状态机持有捕获引用,延长其生命周期。

追问

  • 异步 Lambda 订阅事件?答:事件签名若非 Task 回调,仍为 async void;内部需自处理异常。
  • 局部函数与 Lambda 选择?答:需命名/递归/多语句用局部函数;传委托用 Lambda。

04.6.2.1-017 异步与线程是什么关系?

一句话结论

异步是「可暂停等待、完成后恢复」的机制,不等于多线程;IO 异步等待期间不占线程,CPU 密集工作才需要线程池线程执行计算。

概念解释

IO 操作依赖操作系统异步通知,等待期间线程可服务其他请求;CPU 密集通过 Task.Run 调度线程池。混淆两类工作会错误占用线程或不必要切线程。

原理流程

  1. IO 异步:提交异步请求,等待期间释放线程。
  2. CPU 计算:排队线程池,由工作线程执行。
  3. 完成后续体恢复状态机。

代码或图示

var io = await ReadFromDbAsync();          // 不占线程等待
var cpu = await Task.Run(() => HeavyCalc()); // 线程池执行计算

常见误区

  • 以为 await 一定新开线程:等待 IO 不新开。
  • 把 CPU 计算包在异步 API 里冒充异步:仍是阻塞计算,应区分工作类型。

追问

  • 高并发 IO 服务为什么能少线程?答:等待不占线程,线程只在实际计算/恢复时使用。
  • 线程池线程耗尽表现?答:任务排队、延迟升高、请求堆积;见线程池章节。

04.6.2.1-018 ValueTask 使用限制与复用?

一句话结论

ValueTask 设计为单次消费:await 后不应再次等待或重复取结果;需要保存/复用应先 AsTask() 转为 Task。

概念解释

ValueTask 内部可能持有已完成值或 Task 引用,状态不保证可多次读取。库方法返回 ValueTask 时调用方应遵循单次 await 约定,避免未定义行为。

原理流程

  1. 方法返回 ValueTask 携带结果或 Task。
  2. 调用方单次 await 消费。
  3. 需缓存/传递时 AsTask 取得可复用 Task。

代码或图示

ValueTask<int> vt = FastAsync();
int a = await vt;
// 禁止再次 await vt;需要复用:Task<int> t = FastAsync().AsTask();

常见误区

  • 把 ValueTask 存入字典后续 await:不保证可重复消费。
  • 以为 ValueTask 与 Task 完全等价:内存布局与消费约束不同。

追问

  • ValueTask 能否同步取结果?答:可在确认完成后读取 Result,但语义需按文档;不确定就 await。
  • 库 API 选 Task 还是 ValueTask?答:常同步完成的热路径用 ValueTask;通用库默认 Task 更省心。