咨询Python ThreadPool的C#替代方案：多线程执行指定函数

嘿，作为C#新手，你要的这种控制最大并发数（12个线程）、自动复用线程处理输入列表的需求，C#里有好几种成熟且易用的方案，完全能对应你Python中ThreadPool(12).map的用法，我给你详细拆解：

1. 最推荐：Parallel.ForEach（和map用法最接近） #

Parallel.ForEach是.NET提供的高层API，会自动利用线程池，并且可以直接设置最大并发数，代码简洁到和你Python的写法几乎一致，新手友好度拉满。

示例代码：

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    // 你的处理函数，接收字符串输入
    static void MyFunc(string input)
    {
        Console.WriteLine(input);
    }

    static void Main()
    {
        // 你的输入列表（转成字符串类型，符合函数参数要求）
        List<string> inputs = new List<string> 
        { 
            "1", "12", "2", "3", "4", "5", "6", "7", "8", "9", 
            "1", "0", "1", "2", "3", "4", "5", "6", "4", "8", "97", "7" 
        };

        // 设置最大并发数为12，和Python的ThreadPool(12)对应
        Parallel.ForEach(inputs, new ParallelOptions { MaxDegreeOfParallelism = 12 }, input =>
        {
            MyFunc(input);
        });
    }
}

为什么选它？

• 自动管理线程池，线程会自动复用，不用手动处理线程的创建/销毁
• 一行代码完成并发遍历，逻辑清晰，和map的语义完全匹配
• 内部已经处理了任务调度和等待，Main函数会自动等所有任务完成后再退出

2. 更灵活：Task结合SemaphoreSlim（适合异步场景） #

如果你的MyFunc涉及IO操作（比如网络请求、文件读写），或者需要更精细的任务控制（比如捕获异常、自定义任务前后逻辑），可以用Task.Run搭配SemaphoreSlim来限制并发数，这也是.NET中很常用的异步并发模式。

示例代码：

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void MyFunc(string input)
    {
        Console.WriteLine(input);
    }

    // 注意Main方法标记为async
    static async Task Main()
    {
        List<string> inputs = new List<string> 
        { 
            "1", "12", "2", "3", "4", "5", "6", "7", "8", "9", 
            "1", "0", "1", "2", "3", "4", "5", "6", "4", "8", "97", "7" 
        };

        // 初始化信号量，最多允许12个并发任务
        var semaphore = new SemaphoreSlim(12);
        var taskList = new List<Task>();

        foreach (var input in inputs)
        {
            // 等待信号量释放可用的"槽位"
            await semaphore.WaitAsync();
            // 启动异步任务
            taskList.Add(Task.Run(() =>
            {
                try
                {
                    MyFunc(input);
                }
                finally
                {
                    // 任务完成后必须释放信号量，让其他任务可以执行
                    semaphore.Release();
                }
            }));
        }

        // 等待所有任务全部完成
        await Task.WhenAll(taskList);
    }
}

优势：

• 支持异步等待，不会阻塞主线程，适合GUI或Web应用场景
• 对每个任务的生命周期控制更灵活，比如可以在try...finally里加日志、异常处理等
• 同样复用线程池中的线程，避免频繁创建线程的开销

3. 底层方案：直接使用ThreadPool（不推荐新手） #

C#本身也有ThreadPool类，和Python的ThreadPool是同一个概念，但它的API更底层，需要手动跟踪任务的完成状态，代码会繁琐一些，适合需要极致控制的场景，一般不推荐新手使用。

示例代码：

using System;
using System.Collections.Generic;
using System.Threading;

class Program
{
    static void MyFunc(object state)
    {
        string input = state as string;
        Console.WriteLine(input);
    }

    static void Main()
    {
        List<string> inputs = new List<string> 
        { 
            "1", "12", "2", "3", "4", "5", "6", "7", "8", "9", 
            "1", "0", "1", "2", "3", "4", "5", "6", "4", "8", "97", "7" 
        };

        // 用ManualResetEvent跟踪每个任务的完成状态
        ManualResetEvent[] waitEvents = new ManualResetEvent[inputs.Count];

        for (int i = 0; i < inputs.Count; i++)
        {
            waitEvents[i] = new ManualResetEvent(false);
            string input = inputs[i];
            // 将任务排入线程池
            ThreadPool.QueueUserWorkItem(state =>
            {
                try
                {
                    MyFunc(input);
                }
                finally
                {
                    // 标记任务完成
                    ((ManualResetEvent)state).Set();
                }
            }, waitEvents[i]);
        }

        // 等待所有任务完成
        WaitHandle.WaitAll(waitEvents);
    }
}

总结 #

• 如果只是简单的CPU密集型遍历处理，优先选Parallel.ForEach，代码最简洁，和你Python的用法最匹配
• 如果涉及异步IO或需要精细控制，选Task+SemaphoreSlim
• 直接用ThreadPool的场景很少，新手可以暂时不用深入

内容的提问来源于stack exchange，提问作者Gautam Kumar Giri