有关ThreadPool.QueueUserWorkItem的一些用法

有关ThreadPool.QueueUserWorkItem的一些用法, 

以下示例使用 QueueUserWorkItem(WaitCallback) 方法重载将任务（由 ThreadProc 方法表示）排队，以在线程可用时执行。 此重载未提供任何任务信息。 因此，方法可用的 ThreadProc 信息仅限于该方法所属的对象。

using System;
using System.Threading;
public class Example 
{
    public static void Main() 
    {
        //把任务加入队列
        ThreadPool.QueueUserWorkItem(ThreadProc);
        Console.WriteLine("Main thread does some work, then sleeps.");
        //人为等待1秒
        Thread.Sleep(1000);
        Console.WriteLine("Main thread exits.");
    }
    //要在线程内执行的任务
    static void ThreadProc(Object stateInfo) 
    {
        // No state object was passed to QueueUserWorkItem, so stateInfo is null.
        Console.WriteLine("Hello from the thread pool.");
    }
}
// The example displays output like the following:
//       Main thread does some work, then sleeps.
//       Hello from the thread pool.
//       Main thread exits.

以下示例使用 .NET 线程池来计算 Fibonacci 20 到 40 之间的五个数字的结果。 每个 Fibonacci 结果都由 Fibonacci 类表示，该类提供一个名为 ThreadPoolCallback 的方法，用于执行计算。 创建表示每个 Fibonacci 值的对象，并将 ThreadPoolCallback 方法传递给 QueueUserWorkItem，它分配池中的一个可用线程来执行此方法。

由于每个对象都有 Fibonacci 一个半随机值用于计算，并且每个线程都将争用处理器时间，因此无法提前知道计算所有五个结果需要多长时间。 这就是在构造期间为每个 Fibonacci 对象传递 ManualResetEvent 类的一个实例的原因。 每个对象在计算完成后向提供的事件对象发出信号，这样主线程就可以阻止执行 WaitAll ，直到所有五 Fibonacci 个对象都计算出一个结果。 然后 Main 方法会显示每个 Fibonacci 结果。

using System;
using System.Threading;
public class Fibonacci
{
    private ManualResetEvent _doneEvent;
    public Fibonacci(int n, ManualResetEvent doneEvent)
    {
        N = n;
        _doneEvent = doneEvent;
    }
    public int N { get; }
    public int FibOfN { get; private set; }
    public void ThreadPoolCallback(Object threadContext)
    {
        int threadIndex = (int)threadContext;
        Console.WriteLine($"Thread {threadIndex} started...");
        FibOfN = Calculate(N);
        Console.WriteLine($"Thread {threadIndex} result calculated...");
        _doneEvent.Set();
    }
    public int Calculate(int n)
    {
        if (n <= 1)
        {
            return n;
        }
        return Calculate(n - 1) + Calculate(n - 2);
    }
}
public class ThreadPoolExample
{
    static void Main()
    {
        const int FibonacciCalculations = 5;
        var doneEvents = new ManualResetEvent[FibonacciCalculations];
        var fibArray = new Fibonacci[FibonacciCalculations];
        var rand = new Random();
        Console.WriteLine($"Launching {FibonacciCalculations} tasks...");
        for (int i = 0; i < FibonacciCalculations; i++)
        {
            doneEvents[i] = new ManualResetEvent(false);
            var f = new Fibonacci(rand.Next(20, 40), doneEvents[i]);
            fibArray[i] = f;
            ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i);
        }
        WaitHandle.WaitAll(doneEvents);
        Console.WriteLine("All calculations are complete.");
        for (int i = 0; i < FibonacciCalculations; i++)
        {
            Fibonacci f = fibArray[i];
            Console.WriteLine($"Fibonacci({f.N}) = {f.FibOfN}");
        }
    }
}
// The output is similar to:
// Launching 5 tasks...
// Thread 3 started...
// Thread 4 started...
// Thread 2 started...
// Thread 1 started...
// Thread 0 started...
// Thread 2 result calculated...
// Thread 3 result calculated...
// Thread 4 result calculated...
// Thread 1 result calculated...
// Thread 0 result calculated...
// All calculations are complete.
// Fibonacci(35) = 9227465
// Fibonacci(27) = 196418
// Fibonacci(25) = 75025
// Fibonacci(25) = 75025
// Fibonacci(27) = 196418