1. Главная идея: async — не про потоки¶

Console.WriteLine($"Main start       : thread {Environment.CurrentManagedThreadId}");   // PREDICT:
await DemoAsync();
Console.WriteLine($"Main end         : thread {Environment.CurrentManagedThreadId}");   // PREDICT:

static async Task DemoAsync()
{
    Console.WriteLine($"  before await   : thread {Environment.CurrentManagedThreadId}"); // PREDICT:
    await Task.Delay(200);
    Console.WriteLine($"  after Delay    : thread {Environment.CurrentManagedThreadId}"); // PREDICT:

    await Task.CompletedTask;                       // уже завершён
    Console.WriteLine($"  after Completed: thread {Environment.CurrentManagedThreadId}"); // PREDICT:

    await Task.Yield();                             // принудительно уйти и вернуться
    Console.WriteLine($"  after Yield    : thread {Environment.CurrentManagedThreadId}"); // PREDICT:
}

private struct <<<Main>$>g__DemoAsync|0_0>d : IAsyncStateMachine    // вместо метода — структура; на стеке, пока не было паузы
{
    public int <>1__state;                          // где остановились: -1 идёт, 0/1/2 — номер await, -2 конец
    public AsyncTaskMethodBuilder <>t__builder;     // связь с Task, который вернёт DemoAsync
    private TaskAwaiter <>u__1;                     // awaiter для await на Task (строки 14 и 17)
    private YieldAwaitable.YieldAwaiter <>u__2;     // awaiter для await Task.Yield() (строка 20)

    private void MoveNext()                         // всё тело DemoAsync; зовётся на старте и после каждой паузы
    {
        int num = <>1__state;                       // текущее состояние: на каком шаге мы
        try                                         // любое исключение тела уйдёт в catch (строка 71)
        {
            TaskAwaiter awaiter2;                   // локальная копия awaiter'а для Task
            YieldAwaitable.YieldAwaiter awaiter;    // локальная копия awaiter'а для Yield
            switch (num)                            // прыжок на нужное место по номеру состояния
            {
            default:                                // первый вход
                Console.WriteLine($"  before await   : thread {Environment.CurrentManagedThreadId}");           // исходник, строка 13: печать до первого await
                awaiter2 = Task.Delay(200).GetAwaiter();                                                        // исходник, строка 14: запустить Delay и взять его awaiter
                if (!awaiter2.IsCompleted)          // Delay уже завершена? Тогда пауза не нужна
                {
                    num = (<>1__state = 0);         // запомнить, где остановились: ждём первый await
                    <>u__1 = awaiter2;              // сохранить awaiter в поле: после паузы он понадобится
                    <>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref this);                                // ref this = сама машина: builder копирует её в бокс (куча) и подписывает бокс на Delay
                    return;                         // выйти из MoveNext: поток свободен, метод «спит»
                }
                goto IL_009e;                       // завершена сразу: идти дальше без паузы
            case 0:                                 // возобновление после Delay
                awaiter2 = <>u__1;                  // достать сохранённый awaiter
                <>u__1 = default;                   // очистить поле, чтобы не держать лишнее
                num = (<>1__state = -1);            // снова «выполняется»
                goto IL_009e;                       // общий путь с быстрым случаем
            case 1:                                 // возобновление после CompletedTask
                awaiter2 = <>u__1;                  // достать сохранённый awaiter
                <>u__1 = default;                   // очистить поле
                num = (<>1__state = -1);            // снова «выполняется»
                goto IL_0125;                       // общий путь с быстрым случаем
            case 2:                                 // возобновление после Yield
                awaiter = <>u__2;                   // достать сохранённый awaiter Yield
                <>u__2 = default;                   // очистить поле
                num = (<>1__state = -1);            // снова «выполняется»
                break;                              // выйти из switch к строке 68
            IL_009e:                                // сюда приходят после Delay: сразу или после паузы
                awaiter2.GetResult();               // забрать результат Delay (бросит, если она упала)
                Console.WriteLine($"  after Delay    : thread {Environment.CurrentManagedThreadId}");           // исходник, строка 15: печать после Delay
                awaiter2 = Task.CompletedTask.GetAwaiter();                                                     // исходник, строка 17: взять awaiter у CompletedTask
                if (!awaiter2.IsCompleted)          // CompletedTask завершена всегда: ветка паузы не выполнится
                {
                    num = (<>1__state = 1);         // запомнить: ждём второй await
                    <>u__1 = awaiter2;              // сохранить awaiter
                    <>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref this);                                // бокс уже есть: берётся тот же
                    return;                         // выйти из MoveNext
                }
                goto IL_0125;                       // к продолжению без паузы
            IL_0125:                                // сюда приходят после CompletedTask
                awaiter2.GetResult();               // забрать результат (исключений нет)
                Console.WriteLine($"  after Completed: thread {Environment.CurrentManagedThreadId}");           // исходник, строка 18: печать после CompletedTask
                awaiter = Task.Yield().GetAwaiter();                                                            // исходник, строка 20: взять awaiter у Yield
                if (!awaiter.IsCompleted)           // IsCompleted у Yield всегда false: пауза будет
                {
                    num = (<>1__state = 2);         // запомнить: ждём третий await
                    <>u__2 = awaiter;               // сохранить awaiter Yield
                    <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);                                 // бокс уже есть: берётся тот же; продолжение — в очередь пула
                    return;                         // выйти из MoveNext
                }
                break;                              // путь без паузы (для Yield недостижим)
            }
            awaiter.GetResult();                    // забрать результат Yield
            Console.WriteLine($"  after Yield    : thread {Environment.CurrentManagedThreadId}");               // исходник, строка 21: печать после Yield
        }
        catch (Exception exception)                 // любое необработанное исключение тела
        {
            <>1__state = -2;                        // метод завершён (с ошибкой)
            <>t__builder.SetException(exception);   // записать исключение в Task
            return;                                 // выйти, SetResult не вызывать
        }
        <>1__state = -2;                            // метод завершён успешно
        <>t__builder.SetResult();                   // завершить Task, который вернул DemoAsync
    }
}

[AsyncStateMachine(typeof(<<<Main>$>g__DemoAsync|0_0>d))]
static Task DemoAsync()
{
    <<<Main>$>g__DemoAsync|0_0>d stateMachine = default;
    stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
    stateMachine.<>1__state = -1;
    stateMachine.<>t__builder.Start(ref stateMachine);
    return stateMachine.<>t__builder.Task;
}

private class AsyncStateMachineBox<TStateMachine> : Task<TResult>, IAsyncStateMachineBox  // бокс — это и есть Task, который вернёт async-метод
    where TStateMachine : IAsyncStateMachine                    // тип машины известен компилятору: своя версия класса на каждый метод
{
    private static readonly ContextCallback s_callback = ExecutionContextCallback;        // один статический делегат на тип: чтобы не создавать его на каждый вызов

    public TStateMachine StateMachine;                          // копия вашей структуры-машины: состояние, builder, awaiter'ы, локальные

    public Action MoveNextAction => (Action)(m_action ?? (m_action = new Action(MoveNext)));  // Action на MoveNext для awaiter'ов без поддержки бокса; создаётся лениво, один раз

    public ref ExecutionContext Context => ref Unsafe.As<object, ExecutionContext>(ref m_stateObject);  // ExecutionContext лежит в унаследованном поле Task m_stateObject: без нового поля

    private static void ExecutionContextCallback(object s)      // то, что выполняется внутри восстановленного контекста
    {
        Unsafe.As<AsyncStateMachineBox<TStateMachine>>(s).StateMachine.MoveNext();        // приведение без проверки типа и прямой вызов MoveNext машины, без интерфейса
    }

    public AsyncStateMachineBox()                               // конструктор бокса
    {
        m_stateFlags |= 2048;                                   // флаг 0x800 HiddenState: m_stateObject занят контекстом, а не AsyncState
    }

    internal sealed override void ExecuteFromThreadPool(Thread threadPoolThread)          // вызывается пулом, когда достаёт бокс из очереди как рабочий элемент
    {
        MoveNext(threadPoolThread);                             // MoveNext с потоком пула: от него зависит способ подмены контекста
    }

    public void MoveNext()                                      // вызов «снаружи»: из инлайн-продолжения или через MoveNextAction
    {
        MoveNext(null);                                         // потока пула нет
    }

    private void MoveNext(Thread threadPoolThread)              // единая реализация MoveNext бокса
    {
        bool flag = TplEventSource.Log.IsEnabled();             // включена ли трассировка событий TPL (обычно нет)
        if (flag)
        {
            TplEventSource.Log.TraceSynchronousWorkBegin(Id, CausalitySynchronousWork.Execution);  // событие «синхронная работа началась»
        }
        ExecutionContext context = Context;                     // контекст, захваченный при приостановке
        if (context == null)                                    // контекст не захвачен (так бывает только при SuppressFlow)
        {
            StateMachine.MoveNext();                            // прямой вызов MoveNext вашей машины
        }
        else if (threadPoolThread == null)                      // вызвали не из пула (например, инлайн из SetResult)
        {
            ExecutionContext.RunInternal(context, s_callback, this);                      // поставить контекст на поток, выполнить, вернуть прежний
        }
        else                                                    // вызвал пул потоков
        {
            ExecutionContext.RunFromThreadPoolDispatchLoop(threadPoolThread, context, s_callback, this);  // то же, но после работы поток пула очищается (SynchronizationContext тоже)
        }
        if (IsCompleted)                                        // машина дошла до конца (результат, исключение или отмена)?
        {
            ClearStateUponCompletion();                         // тогда освободить всё, что бокс удерживал
        }
        if (flag)                                               // трассировка включена?
        {
            TplEventSource.Log.TraceSynchronousWorkEnd(CausalitySynchronousWork.Execution);  // событие «синхронная работа закончилась»
        }
    }

    public void ClearStateUponCompletion()                      // очистка после завершения метода
    {
        if (System.Threading.Tasks.Task.s_asyncDebuggingEnabled)                          // режим отладки async включён? (обычно нет)
        {
            System.Threading.Tasks.Task.RemoveFromActiveTasks(this);                      // снять бокс с учёта отладчика
        }
        StateMachine = default;                                 // обнулить копию машины: не держать ваши объекты, пока кто-то держит Task
        Context = null;                                         // отпустить ExecutionContext
        if (AsyncMethodBuilderCore.TrackAsyncMethodCompletion)                            // отладочный бокс с финализатором? (обычно нет)
        {
            GC.SuppressFinalize(this);                          // финализатор больше не нужен
        }
    }

    IAsyncStateMachine IAsyncStateMachineBox.GetStateMachineObject()                      // для отладчика и трассировки
    {
        return StateMachine;                                    // отдаёт машину отладчику как IAsyncStateMachine (упакованную копию)
    }
}

private static IAsyncStateMachineBox GetStateMachineBox<TStateMachine>(                         // зовётся из AwaitUnsafeOnCompleted на каждой паузе
    ref TStateMachine stateMachine, [NotNull] ref Task<TResult> taskField)                      // stateMachine — машина на стеке; taskField — поле m_task builder'а
    where TStateMachine : IAsyncStateMachine
{
    ExecutionContext executionContext = ExecutionContext.Capture();                             // снимок контекста на момент этой паузы (чтение ссылки, глава 7)
    if (taskField is AsyncStateMachineBox<TStateMachine> asyncStateMachineBox)                  // бокс уже создан на прошлой паузе?
    {
        if (asyncStateMachineBox.Context != executionContext)   // между паузами могли записать AsyncLocal
        {
            asyncStateMachineBox.Context = executionContext;    // тогда обновить снимок в боксе
        }
        return asyncStateMachineBox;                            // тот же бокс, новых аллокаций нет
    }
    if (taskField is AsyncStateMachineBox<IAsyncStateMachine> asyncStateMachineBox2)            // бокс без типа машины, созданный заранее для отладчика (редкий путь)
    {
        if (asyncStateMachineBox2.StateMachine == null)         // машина в него ещё не записана?
        {
            Debugger.NotifyOfCrossThreadDependency();           // сообщить отладчику о зависимости от других потоков
            asyncStateMachineBox2.StateMachine = stateMachine;                                  // записать машину в бокс (копия)
        }
        asyncStateMachineBox2.Context = executionContext;       // сохранить контекст
        return asyncStateMachineBox2;                           // вернуть этот бокс
    }
    Debugger.NotifyOfCrossThreadDependency();                   // тот же сигнал отладчику (в обычном запуске безвредно)
    AsyncStateMachineBox<TStateMachine> asyncStateMachineBox3 =                                 // первая пауза вызова: бокса ещё нет, создаём
        (AsyncStateMachineBox<TStateMachine>)(taskField = (AsyncMethodBuilderCore.TrackAsyncMethodCompletion  // taskField = …: бокс сразу становится builder.Task
            ? CreateDebugFinalizableAsyncStateMachineBox<TStateMachine>()                       // режим отладки с финализатором (обычно выключен)
            : new AsyncStateMachineBox<TStateMachine>()));      // обычно: одна аллокация на весь вызов
    asyncStateMachineBox3.StateMachine = stateMachine;          // копия машины со стека в бокс; дальше живёт только копия
    asyncStateMachineBox3.Context = executionContext;           // ExecutionContext этой паузы — в бокс
    if (TplEventSource.Log.IsEnabled())                         // трассировка событий TPL включена? (обычно нет)
    {
        AsyncMethodBuilderCore.LogTraceOperationBegin(asyncStateMachineBox3, stateMachine.GetType());  // событие «началась асинхронная операция»
    }
    if (System.Threading.Tasks.Task.s_asyncDebuggingEnabled)    // включён режим отладки async-задач? (обычно нет)
    {
        System.Threading.Tasks.Task.AddToActiveTasks(asyncStateMachineBox3);                    // записать бокс в список активных задач отладчика
    }
    return asyncStateMachineBox3;                               // builder подпишет этот бокс на ожидаемую задачу
}

public struct AsyncTaskMethodBuilder
{
    private Task<VoidTaskResult> m_task;

    public Task Task => m_task ?? InitializeTaskAsPromise();

    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
    {
        AsyncTaskMethodBuilder<VoidTaskResult>.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref m_task);
    }

    public void SetResult()
    {
        if (m_task == null)
        {
            m_task = System.Threading.Tasks.Task.s_cachedCompleted;
        }
        else
        {
            AsyncTaskMethodBuilder<VoidTaskResult>.SetExistingTaskResult(m_task, default);
        }
    }
}

Console.WriteLine();
Console.WriteLine("== 4. Бокс машины состояний ==");
Task pending = WaitAsync(300);          // приостановится на await: машина уедет в кучу
Describe("ждёт", pending);
await pending;
Describe("завершена", pending);         // мы внутри SetResult: бокс ещё не очистил себя
await Task.Delay(50);
Describe("позже", pending);             // MoveNext бокса вернулся и обнулил StateMachine
Describe("без паузы", WaitAsync(0));    // завершится синхронно: бокс не нужен
Console.WriteLine($"  без паузы дважды — один и тот же объект: {ReferenceEquals(WaitAsync(0), WaitAsync(0))}");

static async Task WaitAsync(int ms)
{
    if (ms > 0)
        await Task.Delay(ms);
}

static void Describe(string title, Task task)
{
    Type type = task.GetType();
    Console.WriteLine($"  {title,-9}: {TypeName(type)}, Status={task.Status}");
    FieldInfo? field = type.GetField("StateMachine");             // поле бокса с копией машины
    if (field is null)
        return;
    object machine = field.GetValue(task)!;
    foreach (FieldInfo f in machine.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))

private class DelayPromise : Task
{
    private static readonly TimerCallback s_timerCallback = TimerCallback;

    private readonly ITimer _timer;

    internal DelayPromise(uint millisecondsDelay, TimeProvider timeProvider)
    {
        if (TplEventSource.Log.IsEnabled())
        {
            TplEventSource.Log.TraceOperationBegin(Id, "Task.Delay", 0L);
        }
        if (s_asyncDebuggingEnabled)
        {
            AddToActiveTasks(this);
        }
        if (millisecondsDelay == uint.MaxValue)
        {
            return;
        }
        if (timeProvider == TimeProvider.System)
        {
            _timer = new TimerQueueTimer(s_timerCallback, this, millisecondsDelay, uint.MaxValue, flowExecutionContext: false);
        }
        else
        {
            using (ExecutionContext.SuppressFlow())
            {
                _timer = timeProvider.CreateTimer(s_timerCallback, this, TimeSpan.FromMilliseconds(millisecondsDelay), Timeout.InfiniteTimeSpan);
            }
        }
        if (IsCompleted)
        {
            _timer.Dispose();
        }
    }

    private static void TimerCallback(object state)
    {
        ((DelayPromise)state).CompleteTimedOut();
    }

    private void CompleteTimedOut()
    {
        if (TrySetResult())
        {
            Cleanup();
            if (s_asyncDebuggingEnabled)
            {
                RemoveFromActiveTasks(this);
            }
            if (TplEventSource.Log.IsEnabled())
            {
                TplEventSource.Log.TraceOperationEnd(Id, AsyncCausalityStatus.Completed);
            }
        }
    }

    protected virtual void Cleanup()
    {
        _timer?.Dispose();
    }
}

Thread thread = new Thread(TimerThread);
thread.Name = ".NET Timer";
thread.IsBackground = true;
thread.UnsafeStart();

private static void TimerThread()
{
    AutoResetEvent autoResetEvent = s_timerEvent;
    Lock obj = s_timerEventLock;
    List<TimerQueue> list = s_scheduledTimersToFire;
    List<TimerQueue> list2;
    using (obj.EnterScope())
    {
        list2 = s_scheduledTimers;
    }
    int num = -1;
    while (true)
    {
        autoResetEvent.WaitOne(num);
        long tickCount = TickCount64;
        num = int.MaxValue;
        using (obj.EnterScope())
        {
            for (int num2 = list2.Count - 1; num2 >= 0; num2--)
            {
                TimerQueue timerQueue = list2[num2];
                long num3 = timerQueue._scheduledDueTimeMs - tickCount;
                if (num3 <= 0)
                {
                    timerQueue._isScheduled = false;
                    list.Add(timerQueue);
                    int num4 = list2.Count - 1;
                    if (num2 != num4)
                    {
                        list2[num2] = list2[num4];
                    }
                    list2.RemoveAt(num4);
                }
                else if (num3 < num)
                {
                    num = (int)num3;
                }
            }
        }
        if (list.Count > 0)
        {
            foreach (TimerQueue item in list)
            {
                ThreadPool.UnsafeQueueHighPriorityWorkItemInternal(item);
            }
            list.Clear();
        }
        if (num == int.MaxValue)
        {
            num = -1;
        }
    }
}

private void FireNextTimers()
{
    TimerQueueTimer timerQueueTimer = null;
    using (SharedLock.EnterScope())
    {
        ...
        TimerQueueTimer timerQueueTimer2 = _shortTimers;
        ...
            while (timerQueueTimer2 != null)
            {
                ...
                long num3 = timerQueueTimer2._dueTime - num2;
                if (num3 <= 0)
                {
                    ...
                    DeleteTimer(timerQueueTimer2);
                    if (timerQueueTimer == null)
                    {
                        timerQueueTimer = timerQueueTimer2;
                    }
                    else
                    {
                        ThreadPool.UnsafeQueueUserWorkItemInternal(timerQueueTimer2, preferLocal: false);
                    }
                }
                ...
            }
        ...
    }
    timerQueueTimer?.Fire();
}

Console.WriteLine("== 2. Task как работа и Task как обещание ==");
Task<int> work = Task.Run(() =>
{
    Console.WriteLine($"  тело Task.Run  : {Where()}");          // код, который занимает поток
    return 1;
});
var tcs = new TaskCompletionSource<int>();
using var timer = new Timer(_ => tcs.SetResult(2), null, 100, Timeout.Infinite);
Task delay = Task.Delay(100);
Console.WriteLine($"  обещание до    : {tcs.Task.Status}");     // WaitingForActivation: кода внутри нет вообще
await Task.WhenAll(work, tcs.Task, delay);
Console.WriteLine($"  обещание после : {tcs.Task.Status}, результат {tcs.Task.Result}");
Console.WriteLine($"  типы           : Task.Run -> {Name(work)}, TCS -> {Name(tcs.Task)}, Task.Delay -> {Name(delay)}");

Console.WriteLine("== 3. 10 000 ожиданий ==");
int before = ThreadPool.ThreadCount;
var continuationThreads = new ConcurrentDictionary<int, byte>();
var sw = Stopwatch.StartNew();
Task all = Task.WhenAll(Enumerable.Range(0, 10_000).Select(async _ =>
{
    await Task.Delay(500);
    continuationThreads.TryAdd(Environment.CurrentManagedThreadId, 0);   // кто выполнил продолжение
}));
await Task.Delay(250);
int during = ThreadPool.ThreadCount;                                      // середина ожидания
await all;
Console.WriteLine($"  10 000 x Delay(500): {sw.ElapsedMilliseconds} мс");
Console.WriteLine($"  потоков пула: до {before}, во время ожидания {during}, после {ThreadPool.ThreadCount}");
Console.WriteLine($"  продолжения выполнили {continuationThreads.Count} разных потоков");