为什么我的TPL程序比它的Async/Await对应程序使用更多的线程池资源？

Question

我正在编写一个程序，演示在服务器可伸缩性上下文中使用异步IO的好处。程序并发地使用一个异步方法，然后报告参与异步处理的线程的ID。

为了说明,请考虑以下内容：

static async Task<TimeSpan> AsyncCalling(TimeSpan time)
{
    using (SleepService.SleepServiceClient client = new SleepService.SleepServiceClient())
    {
        TimeSpan response = await client.SleepAsync(time);
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId);

        response += await client.SleepAsync(TimeSpan.FromTicks(time.Ticks / 2));
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId);

        return response;
    }
}

int numberOfWorkItems = 50;
for (int i = 0; i < numberOfWorkItems; ++i)
{
    TimeSpan value = TimeSpan.FromSeconds((i % 3) + 1);
    ThreadPool.QueueUserWorkItem(arg => { TimeSpan t = AsyncCalling(value).Result; });

    Thread.Sleep(300);
}

static Task<TimeSpan> TaskAsyncCalling(TimeSpan time)
{
    SleepService.SleepServiceClient client = new SleepService.SleepServiceClient();

    return client.SleepAsync(time)
                 .ContinueWith(t =>
                 {
                     TimeSpan result = t.Result;
                     Console.WriteLine(Thread.CurrentThread.ManagedThreadId);

                     return client.SleepAsync(TimeSpan.FromTicks(time.Ticks / 2))
                                  .ContinueWith(t1 =>
                                  {
                                      result += t1.Result;
                                      Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
                                      (client as IDisposable).Dispose();

                                      return result;
                                  });
                 })
                 .Unwrap();
}

在同一上下文中调用taskasyncalling时，输出结果完全不同。这些任务通常需要更长的时间来执行，并且唯一线程ID的总数通常在30个左右（同样，对于我的2核机器）。

为什么会出现这种差距呢？我知道await不是task 的普通包装，但是线程池是共同的分母，我希望在TPL实现中也能出现同样聪明的线程重用。

有没有另一种方法可以重写TPL方法，以达到相同的结果而不阻塞？

public TimeSpan Sleep(TimeSpan time)
{
    Thread.Sleep(time);
    return time;
}

Answer 1

在这种情况下，经典TPL版本比async/await版本使用更多的线程，因为每个continuewith延续都是在单独的池线程上执行的。

使用TaskContinuationSoptions.ExecuteSynchronology修复此问题：

static Task<TimeSpan> TaskAsyncCalling(TimeSpan time)
{
    SleepService.SleepServiceClient client = new SleepService.SleepServiceClient();

    return client.SleepAsync(time)
        .ContinueWith(t =>
        {
            TimeSpan result = t.Result;
            Console.WriteLine(Thread.CurrentThread.ManagedThreadId);

            return client.SleepAsync(TimeSpan.FromTicks(time.Ticks / 2))
                .ContinueWith(t1 =>
                {
                    result += t1.Result;
                    Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
                    (client as IDisposable).Dispose();

                    return result;
                }, TaskContinuationsOptions.ExecuteSynchronously);
         }, TaskContinuationsOptions.ExecuteSynchronously)
         .Unwrap();
 }

OTOH,await连续操作通常是同步执行的（如果操作是在同一同步上下文上完成的,或者如果在两个执行点都没有同步）。所以它需要少获取两个线程。

一个很好的相关阅读：“为什么是TaskContinuationSoptions.ExecuteSynchronology opt-in？”