未使用Task.Run时Async Task为何多线程运行？相关技术问询

测试代码 #

using System;
using System.Threading;
using System.Threading.Tasks;

static class Program {
    static TaskCompletionSource tsc;
    static async Task F1(int i) {
        // PART 1
        await tsc.Task;
        // PART 2
        Console.WriteLine($"call: {i}, thread: {Thread.CurrentThread.GetHashCode()}");
    }
    static async Task Main() {
        tsc = new();
        var tasks = new Task[5];
        for(int i = 0; i < tasks.Length; i++)
        {
            F1(i);
        }
        tsc.SetResult();
        Console.WriteLine("what?!");
        //await Task.Yield();
        Console.WriteLine("done");
    }
}

实际运行结果 #

call: 0, thread: 1
call: 3, thread: 21
call: 1, thread: 17
call: 2, thread: 20
what?!
done
call: 4, thread: 19

问题1：无需Task.Run，Async Task就会在不同线程继续执行？这个假设正确吗？ #

不完全准确，但在你的控制台场景下会出现这种情况，核心原因是同步上下文（SynchronizationContext）：

• 异步方法里await之前的代码，确实会在调用它的线程（这里是主线程）执行。
• 当await的任务完成后，.NET会尝试把后续代码调度到当前线程捕获的同步上下文中执行。如果没有捕获到自定义同步上下文（比如控制台程序默认就没有），就会 fallback 到ThreadPool线程池。
• 你调用tsc.SetResult()后，tsc.Task变为已完成状态，此时await后的PART2代码会被线程池的空闲线程拾取执行，所以你看到了多个不同的线程ID。
• 要是在WinForms/WPF这类有专属同步上下文的环境里，await后的代码会回到原UI线程，不会跑到线程池。

问题2：能否强制所有Async Task仅在主线程空闲时执行？ #

可以实现，关键是给主线程绑定一个自定义同步上下文，让所有await后的回调都排队到主线程的消息循环里，由主线程自己处理。这里提供两种实用方案：

方案1：简单改造Main方法，用Task.Yield配合任务等待

取消注释await Task.Yield()，同时保存任务引用并等待全部完成：

static async Task Main() {
    tsc = new();
    var tasks = new Task[5];
    for(int i = 0; i < tasks.Length; i++)
    {
        tasks[i] = F1(i); // 保存每个F1的任务实例
    }
    tsc.SetResult();
    Console.WriteLine("what?!");
    await Task.Yield(); // 让出主线程，让排队的异步回调先执行
    Console.WriteLine("done");
    await Task.WhenAll(tasks); // 确保所有F1任务都执行完
}

Task.Yield()会把当前方法的后续代码放到同步上下文队列的末尾，让主线程先处理队列里已有的异步回调。不过控制台没有自定义同步上下文，这个方案里PART2可能还是会跑到线程池；如果是有同步上下文的环境，就能回到主线程。如果要严格在主线程执行，看方案2。

方案2：自定义同步上下文，实现主线程消息循环

自己写一个简单的同步上下文，把所有异步回调都排队到主线程处理：

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

class MainThreadSyncContext : SynchronizationContext
{
    private readonly ConcurrentQueue<(SendOrPostCallback Callback, object State)> _callbackQueue = new();
    private readonly AutoResetEvent _queueSignal = new(false);
    private bool _isRunning = true;

    public override void Post(SendOrPostCallback d, object state)
    {
        _callbackQueue.Enqueue((d, state));
        _queueSignal.Set();
    }

    public void RunLoop()
    {
        while (_isRunning)
        {
            _queueSignal.WaitOne();
            while (_callbackQueue.TryDequeue(out var workItem))
            {
                workItem.Callback(workItem.State);
            }
        }
    }

    public void StopLoop() => _isRunning = false;
}

static class Program {
    static TaskCompletionSource tsc;
    static async Task F1(int i) {
        await tsc.Task;
        Console.WriteLine($"call: {i}, thread: {Thread.CurrentThread.GetHashCode()}");
    }
    static void Main() {
        var mainThreadContext = new MainThreadSyncContext();
        SynchronizationContext.SetSynchronizationContext(mainThreadContext);

        tsc = new();
        var tasks = new Task[5];
        for(int i = 0; i < tasks.Length; i++)
        {
            tasks[i] = F1(i);
        }
        tsc.SetResult();
        Console.WriteLine("what?!");
        
        // 启动主线程消息循环，处理所有异步回调
        mainThreadContext.RunLoop();
        
        // 若要退出循环，可在适当位置调用 mainThreadContext.StopLoop()
    }
}

这个方案里，所有await后的代码都会被投递到主线程的回调队列，只有当主线程运行消息循环时才会执行，完全符合你“主线程空闲时执行”的要求，且所有PART2代码都会在主线程运行。

内容的提问来源于stack exchange，提问作者Not a privileged user