.NET中如何高性能执行大量无异步版本的阻塞I/O操作？

你需求的核心是固定并行度、使用独立于 ThreadPool 的线程运行阻塞操作、同时支持 async/await 等待结果，.NET 生态中有以下可直接落地的实现方式：

现有可用方案 #

1. 基于 SemaphoreSlim + ThreadPool 调整的轻量方案 #

如果你可以接受调整 ThreadPool 配置，这是代码量最少的实现：

• 提前将 ThreadPool 的最小工作线程数设置为你需要的并行度（比如1024），避免阻塞操作导致 ThreadPool 缓慢扩容引发的性能问题
• 用 SemaphoreSlim 限制并发数，所有阻塞调用用 Task.Run 包装，最终通过 Task.WhenAll 等待所有执行完成
  示例代码：

// 初始化阶段执行一次，设置最小线程数
ThreadPool.SetMinThreads(1024, 1024);

async Task<List<TResult>> RunBlockingOperationsAsync<TSource, TResult>(IEnumerable<TSource> inputs, Func<TSource, TResult> blockingFunc)
{
    using var semaphore = new SemaphoreSlim(1024);
    var tasks = inputs.Select(async input =>
    {
        await semaphore.WaitAsync();
        try
        {
            return await Task.Run(() => blockingFunc(input));
        }
        finally
        {
            semaphore.Release();
        }
    });
    return (await Task.WhenAll(tasks)).ToList();
}

该方案不需要自己维护线程生命周期，SemaphoreSlim 可以严格控制并行度，不会出现超过设置阈值的线程数。如果更习惯同步并行写法，也可以直接使用 Parallel.ForEach，指定 MaxDegreeOfParallelism 为你需要的并行度即可，底层逻辑和上述方案一致，默认使用 ThreadPool 线程。

2. 独立固定线程池方案（完全不占用 ThreadPool） #

如果你完全不想使用 ThreadPool 运行阻塞操作，可以基于 BlockingCollection 实现自定义的固定线程池，搭配 TaskCompletionSource 提供可 await 的结果，线程会全程复用不会为每个任务新建：

public class FixedThreadPoolExecutor : IDisposable
{
    private readonly BlockingCollection<(Delegate Delegate, object[] Args, TaskCompletionSource Tcs)> _taskQueue = new();
    private readonly Thread[] _threads;

    public FixedThreadPoolExecutor(int threadCount)
    {
        _threads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++)
        {
            _threads[i] = new Thread(WorkLoop)
            {
                IsBackground = true,
                Name = $"FixedPoolThread-{i}"
            };
            _threads[i].Start();
        }
    }

    private void WorkLoop()
    {
        foreach (var item in _taskQueue.GetConsumingEnumerable())
        {
            try
            {
                var result = item.Delegate.DynamicInvoke(item.Args);
                if (item.Tcs.GetType().IsGenericType)
                {
                    item.Tcs.GetType().GetProperty(nameof(TaskCompletionSource<object>.Result))?.SetValue(item.Tcs, result);
                }
                item.Tcs.TrySetResult();
            }
            catch (Exception ex)
            {
                item.Tcs.TrySetException(ex);
            }
        }
    }

    public Task<TResult> Enqueue<TResult>(Func<TResult> func)
    {
        var tcs = new TaskCompletionSource<TResult>(TaskCreationOptions.RunContinuationsAsynchronously);
        _taskQueue.Add((func, Array.Empty<object>(), tcs));
        return tcs.Task;
    }

    public void Dispose()
    {
        _taskQueue.CompleteAdding();
        foreach (var thread in _threads) thread.Join();
        _taskQueue.Dispose();
    }
}

使用时直接创建指定线程数的实例，提交任务后 await 即可，完全不占用 ThreadPool 资源。

关于 TaskCreationOptions.LongRunning #

你对它的认知是正确的，这个标记只会提示 TaskScheduler 为当前任务单独创建一个非 ThreadPool 线程，不会复用线程，确实不符合你固定线程数复用的需求。

额外提示：每个线程默认栈内存为1MB，1024个线程会占用约1GB内存，你可以根据实际业务的超时占比调整并行度，避免不必要的内存占用。

内容的提问来源于stack exchange，提问作者webbertee