c# - 异步/等待问题 - 等待的操作结束会发生什么？

Question

我想我已经阅读了大约 20 篇 async/await 文章，关于 SO 的多个问题，但我在理解它的工作原理方面仍然存在很多差距，尤其是当涉及多个线程时，以及当它全部使用一个线程完成时。

我自己写了这段代码来测试一个场景:

static async Task Main(string[] args)
        {
            var longTask = DoSomethingLong();

            for (int i = 0; i < 1000; i++)
                Console.Write(".");

            await longTask;
        }

        static async Task DoSomethingLong()
        {
            await Task.Delay(10);
            for (int i = 0; i < 1000; i++)
                Console.Write("<");
        }

我明确让我的 Main 继续将点写入控制台，同时在 DoSomethingLong 中延迟执行被阻止。我看到延迟结束后，点写和 < 符号写开始相互干扰。

我只是想不通:是否有两个线程同时在做这项工作？一个写点，另一个写其他字符？或者它是一个线程但在这些上下文之间切换？我会说这是第一个选项，但我仍然不确定。使用 async/await 时，我什么时候可以期望创建一个额外的线程？我还不清楚。

此外，执行 Mai、到达 await 然后返回写入点的线程是否始终相同？

Answer 1

var longTask = DoSomethingLong();

这一行创建了一个任务。与 Task.Run() 创建的任务相比，这是一个不同的任务。这是一个基于状态机的任务，由 C# 编译器自动生成。这是编译器生成的内容(从 sharplab.io 复制粘贴):

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default
    | DebuggableAttribute.DebuggingModes.DisableOptimizations
    | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints
    | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
public class Program
{
    [CompilerGenerated]
    private sealed class <DoSomethingLong>d__0 : IAsyncStateMachine
    {
        public int <>1__state;

        public AsyncTaskMethodBuilder <>t__builder;

        private int <i>5__1;

        private TaskAwaiter <>u__1;

        private void MoveNext()
        {
            int num = <>1__state;
            try
            {
                TaskAwaiter awaiter;
                if (num != 0)
                {
                    awaiter = Task.Delay(10).GetAwaiter();
                    if (!awaiter.IsCompleted)
                    {
                        num = (<>1__state = 0);
                        <>u__1 = awaiter;
                        <DoSomethingLong>d__0 stateMachine = this;
                        <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
                        return;
                    }
                }
                else
                {
                    awaiter = <>u__1;
                    <>u__1 = default(TaskAwaiter);
                    num = (<>1__state = -1);
                }
                awaiter.GetResult();
                <i>5__1 = 0;
                while (<i>5__1 < 1000)
                {
                    Console.Write("<");
                    <i>5__1++;
                }
            }
            catch (Exception exception)
            {
                <>1__state = -2;
                <>t__builder.SetException(exception);
                return;
            }
            <>1__state = -2;
            <>t__builder.SetResult();
        }

        void IAsyncStateMachine.MoveNext()
        {
            // ILSpy generated this explicit interface implementation from
            // .override directive in MoveNext
            this.MoveNext();
        }

        [DebuggerHidden]
        private void SetStateMachine(IAsyncStateMachine stateMachine)
        {
        }

        void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
        {
            // ILSpy generated this explicit interface implementation from
            // .override directive in SetStateMachine
            this.SetStateMachine(stateMachine);
        }
    }

    [AsyncStateMachine(typeof(<DoSomethingLong>d__0))]
    [DebuggerStepThrough]
    private static Task DoSomethingLong()
    {
        <DoSomethingLong>d__0 stateMachine = new <DoSomethingLong>d__0();
        stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
        stateMachine.<>1__state = -1;
        AsyncTaskMethodBuilder <>t__builder = stateMachine.<>t__builder;
        <>t__builder.Start(ref stateMachine);
        return stateMachine.<>t__builder.Task;
    }
}

实际情况是 DoSomethingLong 方法的第一部分是同步执行的。它是第一个 await 之前的部分。在这种特定情况下，第一个 await 之前没有任何内容，因此对 DoSomethingLong 的调用几乎立即返回。它只需要注册一个延续与其余代码一起，在 10 毫秒后在线程池线程中运行。调用返回后，这段代码在主线程中运行:

for (int i = 0; i < 1000; i++)
    Console.Write(".");

await longTask;

当这段代码运行时，线程池会收到信号以运行预定的延续。它开始在线程池线程中并行运行。

for (int i = 0; i < 1000; i++)
    Console.Write("<");

Console 是线程安全的，这是一件好事，因为它被两个线程同时调用。否则，您的程序可能会崩溃!