使用线程池

简介

创建线程是昂贵的操作，为每一个短暂的异步操作创建线程会产生显著的开销。

在线程池中调用委托

using System;
using System.Threading;

namespace Chapter3.Recipe1
{
    class Program
    {
        static void Main(string[] args)
        {
            int threadId = 0;

            RunOnThreadPool poolDelegate = Test;

            var t = new Thread(() => Test(out threadId));
            t.Start();
            t.Join();

            Console.WriteLine("Thread id: {0}", threadId);

            //调用BeginInvoke()运行委托，回调函数在异步操作完成后被调用
            //BeginInvoke()调用后会立即返回,线程池中的工作线程在执行异步操作时，仍允许继续其他工作。
            IAsyncResult r = poolDelegate.BeginInvoke(out threadId, Callback, "a delegate asynchronous call"); 
            r.AsyncWaitHandle.WaitOne(); //等待异步操作完成
            //事实上EndInvoke()会等待异步操作的完成，所以r.AsyncWaitHandle.WaitOne();并不是必要的
            string result = poolDelegate.EndInvoke(out threadId, r);
            //异步操作完成后，回调函数会被放置到线程池中，确切的说是一个工作线程中。
            Console.WriteLine("Thread pool worker thread id: {0}", threadId);
            Console.WriteLine(result);

            Thread.Sleep(TimeSpan.FromSeconds(2));
        }

        private delegate string RunOnThreadPool(out int threadId);

        private static void Callback(IAsyncResult ar)//回调函数
        {
            Console.WriteLine("Starting a callback...");
            Console.WriteLine("State passed to a callbak: {0}", ar.AsyncState);
            Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
            Console.WriteLine("Thread pool worker thread id: {0}", Thread.CurrentThread.ManagedThreadId);
        }


        private static string Test(out int threadId)
        {
            Console.WriteLine("Starting...");
            Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
            Thread.Sleep(TimeSpan.FromSeconds(2));
            threadId = Thread.CurrentThread.ManagedThreadId;
            return string.Format("Thread pool worker thread id was: {0}", threadId);
        }
    }
}

使用BeginOperationName/EndOperation方法和.NET中的IAsyncResult对象等方式被称为异步编程模型，这样的方法对被称为异步方法。

 向线程池放入异步操作

using System;
using System.Threading;

namespace Chapter3.Recipe2
{
    class Program
    {
        static void Main(string[] args)
        {
            const int x = 1;
            const int y = 2;
            const string lambdaState = "lambda state 2";

            //使用ThreadPool的静态方法QueueUserWorkItem()将方法放到线程池中
            ThreadPool.QueueUserWorkItem(AsyncOperation);
            Thread.Sleep(TimeSpan.FromSeconds(1));
            //Thread.Sleep()让线程池拥有为新操作重用线程的可能性
            ThreadPool.QueueUserWorkItem(AsyncOperation, "async state");
            Thread.Sleep(TimeSpan.FromSeconds(1));
            //使用lambda表达式方式
            ThreadPool.QueueUserWorkItem(state => {
                Console.WriteLine("Operation state: {0}", state);
                Console.WriteLine("Worker thread id: {0}", Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(TimeSpan.FromSeconds(2));
            }, "lambda state");
            //使用闭包机制
            ThreadPool.QueueUserWorkItem(_ =>
            {
                Console.WriteLine("Operation state: {0}, {1}", x + y, lambdaState);
                Console.WriteLine("Worker thread id: {0}", Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(TimeSpan.FromSeconds(2));
            }, "lambda state");

            Thread.Sleep(TimeSpan.FromSeconds(2));
        }

        private static void AsyncOperation(object state)
        {
            Console.WriteLine("Operation state: {0}", state ?? "(null)");
            Console.WriteLine("Worker thread id: {0}", Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(TimeSpan.FromSeconds(2));
        }
    }
}

 使用计时器

using System;
using System.Threading;

namespace Chapter3.Recipe6
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Press 'Enter' to stop the timer...");
            DateTime start = DateTime.Now;
            //传入回调函数，用户状态对象，调用回调函数之前的时间延迟量，时间间隔
            _timer = new Timer(_ => TimerOperation(start), null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2));

            Thread.Sleep(TimeSpan.FromSeconds(6));

            _timer.Change(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(4));

            Console.ReadLine();

            _timer.Dispose();
        }

        static Timer _timer;

        static void TimerOperation(DateTime start)//回调函数，在线程池中被执行
        {
            TimeSpan elapsed = DateTime.Now - start;
            Console.WriteLine("{0} seconds from {1}. Timer thread pool thread id: {2}", elapsed.Seconds, start,
                Thread.CurrentThread.ManagedThreadId);
        }
    }
}

使用BackgroundWorker组件

除了将异步API组织为Begin/End方法对外，还可以启动一个异步操作然后订阅给不同的事件，这种方式被称为基于事件的异步模式（Event-based Asynchronous Pattern,EAP）。

using System;
using System.ComponentModel;
using System.Threading;

namespace Chapter3.Recipe7
{
    class Program
    {
        static void Main(string[] args)
        {
            var bw = new BackgroundWorker();
            bw.WorkerReportsProgress = true; //指示该后台工作线程支持操作进度的通知
            bw.WorkerSupportsCancellation = true; //指示该后台工作线程支持取消操作

            bw.DoWork += Worker_DoWork; //调用RunWorkerAsync()时发生
            bw.ProgressChanged += Worker_ProgressChanged;
            bw.RunWorkerCompleted += Worker_Completed; //后台操作完成、被取消或者异常时发生

            bw.RunWorkerAsync();//后台工作对象bw通过RunWorkerAsync()方法启动异步操作

            Console.WriteLine("Press C to cancel work");
            do
            {
                if (Console.ReadKey(true).KeyChar == 'C')
                {
                    bw.CancelAsync();
                }

            }
            while (bw.IsBusy);//指示是否正在运行异步操作
        }

        static void Worker_DoWork(object sender, DoWorkEventArgs e)
        {
            Console.WriteLine("DoWork thread pool thread id: {0}", Thread.CurrentThread.ManagedThreadId);
            var bw = (BackgroundWorker)sender;
            for (int i = 1; i <= 100; i++)
            {

                if (bw.CancellationPending)//指示应用程序是否已取消程序后台操作
                {
                    e.Cancel = true;
                    return;
                }

                if (i % 10 == 0)
                {
                    bw.ReportProgress(i);
                }

                Thread.Sleep(TimeSpan.FromSeconds(0.1));
            }
            e.Result = 42; //异步操作的结果
        }

        static void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            Console.WriteLine("{0}% completed. Progress thread pool thread id: {1}", e.ProgressPercentage,
                Thread.CurrentThread.ManagedThreadId);
        }

        static void Worker_Completed(object sender, RunWorkerCompletedEventArgs e)
        {
            Console.WriteLine("Completed thread pool thread id: {0}", Thread.CurrentThread.ManagedThreadId);
            if (e.Error != null)//异步操作发生错误
            {
                Console.WriteLine("Exception {0} has occured.", e.Error.Message);
            }
            else if (e.Cancelled)//异步操作被取消
            {
                Console.WriteLine("Operation has been canceled.");
            }
            else//异步操作成功完成
            {
                Console.WriteLine("The answer is: {0}", e.Result);
            }
        }
    }
}