• 前言
• Task.ContinueWith
  • ContinueWith 的产物：ContinuationTask
  • 额外的参数
  • 回调的容器：TaskContinuation
  • Task.ContinueWith 回调的生命周期
    • 阶段一 将回调封装进 ContinueWithTaskContinuation
    • 阶段二 回调的触发
  • 回调执行真正的决定者：ContinueWithTaskContinuation
  • 执行回调的线程
• Task 与 await
  • Awaiter
  • await Anything
    • 实现 INotifyCompletion 接口的 Awaiter 示例
    • 实现 ICriticalNotifyCompletion 接口的 Awaiter 示例
    • INotifyCompletion VS ICriticalNotifyCompletion
  • 有限元状态机
  • AsyncStateMachineBox
  • await Task 的回调在哪执行
  • 同步上下文（SynchronizationContext）导致的死锁问题与 Task.ConfigureAwait(continueOnCapturedContext:false)
  • 为什么没有同步上下文也会死锁
• 总结
• 参考资料

前言

本文为系列博客

2. Task 的回调执行与 await（本文）
3. async 到底干了什么（TODO）
4. 总结与常见误区（TODO）

上一篇我们讲了对 Task 的基本定义：
Task 代表一个任务，其具体类型可能是多种多样的，且有时候对我们来说完全是个黑盒。这个任务可以有结果，可以没有结果，我们能知道这个任务什么时候执行完成，并进行相应的后续处理。

Task 生命周期可以分为任务执行和回调执行两个主要的阶段。上回讲了 Task 的执行阶段，这次我们就接着来看下回调执行阶段。

Task 将回调函数维护在 m_continuationObject 字段上，并通过 TrySetResult 等方法对外（这个对外仅限runtime里Task相关的其他代码）暴露回调的触发方式。

由于 Task 的设计过于复杂，我的理解可能有错误，以后的版本可能会和现在有所出入。本文仅供参考学习，希望大家不要太过于纠结细节，了解设计思路比实现细节更重要。

class Task
{
    // 保存一个或一组回调
    private volatile object? m_continuationObject;

    internal bool TrySetResult()
    {
        // ...
        FinishContinuations();
        // ...
    }

    internal void FinishContinuations()
    {
        // 处理回调的执行
    }
}

class Task : Task
{
    internal bool TrySetResult(TResult result)
    {
        // ...
        this.m_result = result;
        // 复用父类的逻辑
        FinishContinuations();
        // ...
    }
}

本文要讨论的其实就是对上述的补充：

• Task 在把回调函数保存到 m_continuationObject 之前，对回调函数进行了什么样的包装处理？
• Task 的 回调函数是在什么时候被触发的，也就是 Task 的完成与回调的执行是如何进行衔接的？
• Task 所保存的回调函数会在哪里执行？

Task.ContinueWith

往一个 Task 注册回调，有两种方式：直接调用 Task 实例的 ContinueWith 方法，或者使用 await 关键词。我们先看一下前者，await 放在后面单独讲。

ContinueWith 的产物：ContinuationTask

调用 ContinueWith 本质上是创建了一个新的 Task（后面简称为 ContinuationTask）,而这个 ContinuationTask 的执行时间就是 原Task(后面简称为 AntecedentTask) 完成之后。

作为 Task ContinueWith 的返回值的 Task 的子类有以下四个，分别对应四种用法：

1. ContinuationTaskFromTask
   向 Task 注册一个回调

Task task = Task.Run(() => Console.WriteLine("Hello"))
    .ContinueWith(t => Console.WriteLine("World"));

// System.Threading.Tasks.ContinuationTaskFromTask
Console.WriteLine(task.GetType());

2. ContinuationResultTaskFromTask
   向 Task 注册一个回调，并在回调里返回一个新值作为 新Task 的返回值

Task task = Task.Run(() => Console.WriteLine("Hello"))
    .ContinueWith(t => "World");

// System.Threading.Tasks.ContinuationResultTaskFromTask`1[System.String]
Console.WriteLine(task.GetType());

3. ContinuationTaskFromResultTask
   向 Task 注册一个回调, 并且 Task 获取返回值

Task task = Task.Run(() => "Hello")
    .ContinueWith(t => Console.WriteLine($"{t.Result} World"));

// System.Threading.Tasks.ContinuationTaskFromResultTask`1[System.String]
Console.WriteLine(task.GetType());

4. ContinuationResultTaskFromResultTask
   向 Task 注册一个回调，并在回调里返回一个新值作为 新Task 的返回值

Task task = Task.Run(() => "Hello")
    .ContinueWith(t => $"{t.Result} World");

// System.Threading.Tasks.ContinuationResultTaskFromResultTask`2[System.String,System.String]
Console.WriteLine(task.GetType());

因为 Task.ContinueWith 的结果依旧是一个 Task，这个链式的回调注册可以无限地进行。

Task.Run(() => Console.WriteLine(1))
    .ContinueWith(t => Console.WriteLine(2))
    .ContinueWith(t => Console.WriteLine(3))
    .ContinueWith(t => Console.WriteLine(4));

额外的参数

class Task
{
    public Task ContinueWith(
        Action continuationAction,
        CancellationToken cancellationToken,
        TaskContinuationOptions continuationOptions,
        TaskScheduler scheduler)
        {
            // ...
        }
}

我们还可以通过 ContinueWith 的重载向其传入回调函数外的三个参数：

• CancellationToken：协作式取消 Task 的执行，本文暂不展开。
• TaskContinuationOptions：
  前一部分和 TaskCreationOptions 的值完全一致。
  如果设置的是这一部分的值，就会直接转换为 ContinuationTask 的 TaskCreationOptions。TaskScheduler 识别过后进行相应的处理。
  如果设置的是后一部分的值，那么 runtime 在决定把 Task 交给 TaskScheduler 去调度执行前，会根据设置的值做相应的预判逻辑。例如 OnlyOnFaulted 代表在 AntecedentTask 执行过程抛出了异常，runtime 才会去执行 ContinuationTask。

public enum TaskCreationOptions
{
    None = 0,
    PreferFairness = 1,
    LongRunning = 2,
    AttachedToParent = 4,
    DenyChildAttach = 8,
    HideScheduler = 16, // 0x00000010
    RunContinuationsAsynchronously = 64, // 0x00000040
}

public enum TaskContinuationOptions
{
    None = 0,
    PreferFairness = 1,
    LongRunning = 2,
    AttachedToParent = 4,
    DenyChildAttach = 8,
    HideScheduler = 16, // 0x00000010
    LazyCancellation = 32, // 0x00000020
    RunContinuationsAsynchronously = 64, // 0x00000040
    // ---------- 分界线 ----------
    NotOnRanToCompletion = 65536, // 0x00010000
    NotOnFaulted = 131072, // 0x00020000
    NotOnCanceled = 262144, // 0x00040000
    OnlyOnRanToCompletion = NotOnCanceled | NotOnFaulted, // 0x00060000
    OnlyOnFaulted = NotOnCanceled | NotOnRanToCompletion, // 0x00050000
    OnlyOnCanceled = NotOnFaulted | NotOnRanToCompletion, // 0x00030000
    ExecuteSynchronously = 524288, // 0x00080000
}

• TaskScheduler：可以之指定 TaskScheduler 去调度 Task。
  默认是 TaskScheduler.Current，而 TaskScheduler.Current 的默认值是 ThreadPoolTaskScheduler，可以修改成其他实现。

回调的容器：TaskContinuation

我们注意到 m_continuationObject 字段的类型是 object，而 object 类型在数据的存储上有更多的灵活性。

class Task
{
    // 保存一个或一组回调
    private volatile object m_continuationObject;
}

我们看下下面的代码

var antecedentTask = Task.Run(() =>
{
    Thread.Sleep(1000);
    Console.WriteLine("Antecedent Task Completed");
});

PrintContinuationObjectType(antecedentTask);

antecedentTask.ContinueWith(_ => Console.WriteLine("Continuation Task1 Completed"));

PrintContinuationObjectType(antecedentTask);

antecedentTask.ContinueWith(_ => Console.WriteLine("Continuation Task2 Completed"));

PrintContinuationObjectType(antecedentTask);

Console.ReadLine();

void PrintContinuationObjectType(Task task)
{
    var continuationObject = typeof(Task)
        .GetField("m_continuationObject",
            BindingFlags.NonPublic | BindingFlags.Instance)
        .GetValue(task);

    var type = continuationObject?.GetType().FullName ?? "null";
    if (continuationObject is IEnumerable enumerable)
    {
        type += $", Element type: {enumerable.Cast