如何在C#中用Task并行调用DoSomeWork并控制并发数及处理错误？

先来说说你之前代码里的几个关键问题：

• 闭包捕获陷阱：循环中直接使用变量i，Task执行时捕获的是i的引用而非循环当时的数值，导致多个Task最终拿到的是i的最终值，传入DoSomeWork的参数完全不符合预期。
• 信号量泄漏风险：ContinueWith的执行依赖于前置Task的状态，一旦DoSomeWork抛出异常，可能出现信号量未被释放的情况，导致后续任务无法获取许可。
• 未处理异常：后台Task的异常如果没被主动捕获，会导致程序静默失败甚至崩溃。

下面给你两种可靠的实现方案，兼顾并发限制、参数正确性和异常处理：

方案一：用Parallel.ForEach（最简洁的同步场景方案） #

Parallel.ForEach自带并发度控制，.NET框架已经帮你处理了线程池调度、参数传递和异常收集，代码非常简洁：

// 配置最大并行执行数量
var parallelOptions = new ParallelOptions
{
    MaxDegreeOfParallelism = 5 // 替换为你需要的最大并发数
};

try
{
    Parallel.ForEach(SomeNumberList, parallelOptions, n =>
    {
        try
        {
            DoSomeWork(n);
            // 可添加单个任务成功后的自定义逻辑
        }
        catch (Exception ex)
        {
            // 局部处理单个任务的异常，比如记录日志
            Console.WriteLine($"处理数值{n}时出错：{ex.Message}");
            // 如果需要终止所有后续任务，可重新抛出异常
            // throw;
        }
    });
}
catch (AggregateException ae)
{
    // 统一处理所有未被局部捕获的异常
    foreach (var ex in ae.InnerExceptions)
    {
        Console.WriteLine($"全局未处理异常：{ex.Message}");
    }
}

这个方案的优势是无需手动管理线程或信号量，适合DoSomeWork是同步方法的场景。

方案二：用SemaphoreSlim + async/await（灵活的异步兼容方案） #

如果未来DoSomeWork可能改成异步方法，或者你需要更精细的任务调度控制，用SemaphoreSlim结合async/await是更优选择，同时彻底解决你之前的问题：

// 初始化信号量，设置最大并发许可数
var semaphore = new SemaphoreSlim(5); // 替换为你的最大并发数
var taskList = new List<Task>();

foreach (var n in SomeNumberList)
{
    // 捕获当前循环的数值，避免闭包引用问题
    var currentNumber = n;
    taskList.Add(Task.Run(async () =>
    {
        await semaphore.WaitAsync();
        try
        {
            DoSomeWork(currentNumber);
            // 如果是异步方法，替换为 await DoSomeWorkAsync(currentNumber);
        }
        catch (Exception ex)
        {
            // 局部处理单个任务的异常
            Console.WriteLine($"处理数值{currentNumber}时出错：{ex.Message}");
        }
        finally
        {
            // 确保无论任务成功/失败，都释放信号量，避免泄漏
            semaphore.Release();
        }
    }));
}

// 等待所有任务执行完成
try
{
    await Task.WhenAll(taskList);
}
catch (AggregateException ae)
{
    // 统一处理所有未被局部捕获的异常
    foreach (var ex in ae.InnerExceptions)
    {
        Console.WriteLine($"全局未处理异常：{ex.Message}");
    }
}

这个方案的核心改进： #

1. 解决闭包问题：通过var currentNumber = n;捕获当前循环的独立数值，每个Task拿到的都是正确的参数。
2. 信号量安全：用try/finally确保信号量一定会被释放，彻底避免泄漏风险。
3. 异常可控：支持局部处理单个任务异常，也可以让异常冒泡到全局统一处理，灵活度更高。

补充：关于"同一线程多次调用"的误解 #

你之前遇到的"同一线程多次调用"其实是线程池的正常行为——线程池会复用空闲线程来执行新的Task，这不是问题。如果你的DoSomeWork不是线程安全的，需要在方法内部加锁保护共享资源，或者确保方法本身无状态、不依赖共享变量。

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