为什么在使用多个等待时 SynchronizationContext.Post() 仅被调用一次？

Question

考虑以下示例：

async Task DoWork()
{
    await Task.Run(() =>
    {
        for (int i = 0; i < 25; i++)
        {
            Console.WriteLine("Task run 1: " + Thread.CurrentThread.ManagedThreadId);
        }
    });

    // The SynchronizationContext.Post() gets called after Run 1 and before Run 2

    await Task.Run(() =>
    {
        for (int i = 0; i < 25; i++)
        {
            Console.WriteLine("Task run 2: " + Thread.CurrentThread.ManagedThreadId);
        }
    });

    // I expect it to run after Run 2 and before Run 3 as well but it doesn't

    await Task.Run(() =>
    {
        for (int i = 0; i < 25; i++)
        {
            Console.WriteLine("Task run 3: " + Thread.CurrentThread.ManagedThreadId);
        }
    });
}

我希望每次等待操作结束时都会调用 SynchronizationContext.Post() ，但在重写 Post() 之后，像这样

public class MySynchronizationContext
{
  public override void Post(SendOrPostCallback d, object? state)
  {
      Console.WriteLine("Continuation: " + Thread.CurrentThread.ManagedThreadId);
      base.Post(d, state);
  }
}

安装this 在 Main() 的最开始处，

SynchronizationContext.SetSynchronizationContext(new MySynchronizationContext());

它只在第一个 Run() 完成后打印一次消息。

我认为这是因为 Task.Run() 可能会检测到它正在线程池线程上被调用，并且只重用当前线程，但情况似乎并非如此，因为我的一些测试导致 运行 2 和运行 3 在不同的线程上运行。

为什么awaited 任务的完成仅在第一个await 之后运行？

Answer 1

SynchronizationContext.SetSynchronizationContext 方法在当前线程上安装提供的 SynchronizationContext。为了使相同的 SynchronizationContext 能够被后续的 await 捕获并重用，SynchronizationContext 的实现必须确保在原始线程，或者将其自身安装到用于调用延续的任何其他线程上。

您的实现 (MySynchronizationContext) 不会执行此操作。它只是将 Post 调用委托给 base.Post，它调用ThreadPool上的延续。 MySynchronizationContext 实例未安装在任何 ThreadPool 线程上，因此第二个 await 找不到任何可捕获的内容，因此调用第二个延续在 Task.Run 方法完成的任何线程上，它也是一个 ThreadPool 线程。因此，本质上，您获得的行为与使用正确实现的 SynchronizationContext 获得的行为相同，例如 Stephen Cleary 的 AsyncContext，并配置第一个 await ConfigureAwait（假）。

Answer 2

我最终自己弄清楚了。

问题似乎是我对通过 await 捕获当前 SynchronizationContext 的理解无效。

async Task DoWork()
{
    // This is still in the main thread so SynchronizationContext.Current
    // returns an instance of MySynchronizationContext which this
    // await captures.
    await Task.Run(() =>
    {
        for (int i = 0; i < 25; i++)
        {
            Console.WriteLine("Task run 1: " + Thread.CurrentThread.ManagedThreadId);
        }
    });
    // Here it uses the captured MySynchronizationContext to call
    // the .Post() method. The message gets printed to the console and
    // continuation gets put on the ThreadPool

    // This await tries to capture current SynchronizationContext but
    // since we're on the ThreadPool's thread, SynchronizationContext.Current
    // returns null and it uses the default implementation
    // instead of MySynchronizationContext. This is why my message from
    // the overriden .Post() doesn't get printed which made me believe
    // that it didn't call .Post() at all. It did, just not my .Post()
    await Task.Run(() =>
    {
        for (int i = 0; i < 25; i++)
        {
            Console.WriteLine("Task run 2: " + Thread.CurrentThread.ManagedThreadId);
        }
    });
    // .Post() gets called on the default SynchronizationContext

    // Again, we're on the ThreadPool's thread,
    // so the default SynchronizationContext gets captured
    await Task.Run(() =>
    {
        for (int i = 0; i < 25; i++)
        {
            Console.WriteLine("Task run 3: " + Thread.CurrentThread.ManagedThreadId);
        }
    });
}