使用线程池而不是创建线程

/// <summary>
/// 测试单线程、手工线程、线程池
/// </summary>
public static class TestThread
{
    private static uint lowerBound = 0, upperBound = 1000000;
    private const double tolerance = 1.0e-8;//公差

    // 获得数字的平方根
    private static double SquareRoot(double number)
    {
        double guess = 1, error = Math.Abs(guess * guess - number);
        while (error > tolerance)
        {
            guess = (number / guess + guess) / 2;
            error = Math.Abs(guess * guess - number);
        }
        return guess;
    }

    public static double SingleThread()
    {
        Stopwatch start = new Stopwatch();
        start.Start();
        for (uint i = lowerBound; i < upperBound; i++)
        {
            double answer = SquareRoot(i);
        }
        start.Stop();
        return start.ElapsedMilliseconds;
    }

    public static double ManualThreads(int numThreads)
    {
        Stopwatch start = new Stopwatch();
        using (AutoResetEvent e = new AutoResetEvent(false))
        {
            int workerThreads = numThreads;
            start.Start();
            for (int thread = 0; thread < numThreads; thread++)
            {
                Thread t = new Thread(() =>
                {
                    for (uint i = lowerBound; i < upperBound; i++)
                    {
                        //并行计算
                        if (i % numThreads == thread)
                        {
                            double answer = SquareRoot(i);
                        }
                    }
                    //减少计数器的值
                    if (Interlocked.Decrement(ref workerThreads) == 0)
                    {
                        e.Set();//设置事件
                    }
                });
                t.Start();
            }
            //等待信号
            e.WaitOne();
            start.Stop();
            return start.ElapsedMilliseconds;
        }
    }

    public static string content = "线程池输出的内容";
    public static double ThreadPoolThreads(int numThreads)
    {
        Stopwatch start = new Stopwatch();
        //此处使用AutoResetEvent类，用于通知当前线程（等待的线程，即主线程）发生了什么。
        using (AutoResetEvent e = new AutoResetEvent(false))//false标记为非终止状态，即任务未完成
        {
            int workerThreads = numThreads;
            start.Start();
            for (int thread = 0; thread < numThreads; thread++)
            {
                /*WaitCallback,回调委托，代表由系统（程序）自动执行的方法，不需要自己手动去执行。在使用QueueUserWorkItem单个参数方法时，WaitCallback委托中state参数为null；若要使用state参数进行数据处理，需要调用2个参数的QueueUserWorkItem方法。*/
                ThreadPool.QueueUserWorkItem(x =>
                {
                    Console.WriteLine(content);
                    for (uint i = lowerBound; i < upperBound; i++)
                    {
                        //并行计算
                        if (i % numThreads == thread)
                        {
                            double answer = SquareRoot(i);
                        }
                    }
                    //递减计数器的值，Interlocked类是连锁-互锁，为多线程共享的资源在并发时，锁定共享的资源只能同时有一个线程在执行。此处也可以使用lock（关键字）同步锁进行处
                    if (Interlocked.Decrement(ref workerThreads) == 0)
                    {
                        //设置事件状态为终止状态，即任务完成（告诉等待的线程不用等待，可以继续执行了）。
                        e.Set();
                    }
                }, content);
            }
            //等待信号，阻塞当前线程（直到任务完成-即AutoResetEvent设置为终止状态，才继续执行）
            e.WaitOne();
            start.Stop();
            return start.ElapsedMilliseconds;
        }
    }
}

static void Main(string[] args)
{
    try
    {
        double result = TestThread.SingleThread();
        Console.WriteLine("单个线程执行10回百万个数字的平方根的耗时：{0}ms", result * 10);
        result = TestThread.ManualThreads(10);
        Console.WriteLine("手工线程执行10回百万个数字的平方根的耗时：{0}ms", result);
        result = TestThread.ThreadPoolThreads(10);
        Console.WriteLine("线程池执行10回百万个数字的平方根的耗时：{0}ms", result);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex);
    }
    Console.Read();
}