C# 线程知识--使用ThreadPool执行异步操作

     在应用程序中有许多复杂的任务，对于这些任务可能需要使用一个或多个工作线程或I/O线程来协作处理，比如：定时任务、数据库数据操作、web服务、文件的处理等。这些任务可能会非常耗费时间，为了是用户界面能及时响应，就会启用一个其他线程来并行处理任务。线程的创建和销毁操作是非常昂贵的，过多的线程会带来内存资源的消耗以及操作系统调度可执行线程并执行上下文切换导致的时间消耗，所以过多线程会损坏应用程序的性能。如果创建过的线程能反复使用就能解决上面的一些问题，因此，CLR使用了线程池来管理线程。

1. 线程池基础

       每个CLR 拥有一个线程池，这个线程池由CLR控制的APPDomain 共享。在线程池内部，它自己维护着一个操作请求队列，应用程序需要执行某个任务时，就需要调用线程池的一个方法（通常是QueueUserWorkItem 方法）将任务添加到线程池工作项中，线程池就会将任务分派给一个线程池线程处理，如果线程池中没有线程，就会创建一个线程来处理这个任务。当任务执行完成以后，这个线程会回到线程池中处于空闲状态，等待下一个执行任务。由于线程不会销毁，所以使用线程池线程在执行任务的速度上会更快。

      如果线程池中的任务过多超过了现有线程的处理能力时，线程池就会根据需要在创建更多的线程。由于每个线程都要占用一定的内存资源，所以当线程池空闲线程（长时间不执行任务的线程）过多时，线程池中线程会自动醒来销毁多余的空闲线程，以减少资源的使用。

      在线程池内部，所有线程都是后台线程并且调度优先级都为普通（ThreadPriority.Normal），这些线程分为工作者或I/O线程，当线程池线程执行的任务是一个复杂的计算任务时，使用的就是工作者线程。如果执行的任务与I/O相关，就会使用I/O线程。

2. 使用ThreadPool 类执行异步任务

      ThreadPool 类是一个静态类型类，使用ThreadPool 类执行异步时通常调用ThreadPool 的 QueueUserWorkItem 方法，这个方法有一个重载版本，如下：

public static bool QueueUserWorkItem(WaitCallback callBack);
       
public static bool QueueUserWorkItem(WaitCallback callBack, object state);

QueueUserWorkItem 方法接受一个WaitCallback 类型的委托作为回调方法以及可以选择传递一个线程池线程执行回调方法时所需要的数据对象。

WaitCallback 委托类型的定义如下：

public delegate void WaitCallback(object state);

线程池的QueueUserWorkItem方法在调用以后会立即返回，所传递的回调方法会有以后线程池线程执行。使用线程池线程执行异步任务代码如下：

1:   static void Main(string[] args)
2:         {
3:             Console.WriteLine("主线程开始执行任务。线程ID：{0}",Thread.CurrentThread.ManagedThreadId);
4:
5:             //使用 ThreadPool.QueueUserWorkItem 方法将一个异步任务添加到线程池任务队列中，
6:             //可以为线程池线程执行方法时传递一个数据对象，
7:             //如果不需要传递数据可以使用QueueUserWorkItem只有WaitCallback一个参数类型的版本，
8:             //或传递null
9:             ThreadPool.QueueUserWorkItem(state => {
10:                 Console.WriteLine("线程池线程开始执行异步任务。线程ID：{0}",Thread.CurrentThread.ManagedThreadId);
11:                 for (int i = 0; i < 10; i++)
12:                 {
13:                     Console.WriteLine(i);
14:                 }
15:
16:             },null);
17:
18:             Console.WriteLine("主线程执行其他任务。线程ID：{0}", Thread.CurrentThread.ManagedThreadId);
19:             //使调用线程睡眠2000毫秒，等待线程池线程执行完成。
20:             Thread.Sleep(2000);
21:
22:             Console.WriteLine("主线程继续执行任务。线程ID：{0}", Thread.CurrentThread.ManagedThreadId);
23:         }

程序运行结果如图：

 

3.线程池对线程的管理

       CLR 允许开发人员设置线程池需要创建的最大和最小工作者线程和I/O线程，但是最好不要设置线程池的线程数，CLR对线程池的工作者线程和I/O线程的最大线程数设置了1000的默认值。我们可以使用线程池的如下方法对线程池线程数进行设置和获取以及获得最大线程池线程数和当前运行线程数之间的差值：

//设置可以同时处于活动状态的线程池的请求数目。
// 所有大于此数目的请求将保持排队状态，直到线程池线程变为可用。
public static bool SetMaxThreads(int workerThreads, int completionPortThreads);
 // 发出新的请求时，在切换到管理线程创建和销毁的算法之前设置线程池按需创建的线程的最小数量。 
public static bool SetMinThreads(int workerThreads, int completionPortThreads);
 //检索可以同时处于活动状态的线程池请求的数目。 所有大于此数目的请求将保持排队状态，直到线程池线程变为可用。
 public static void GetMaxThreads(out int workerThreads, out int completionPortThreads);
//发出新的请求时，在切换到管理线程创建和销毁的算法之前检索线程池按需创建的线程的最小数量。
 public static void GetMinThreads(out int workerThreads, out int completionPortThreads);

 //获得最大线程池线程数和当前运行线程数之间的差值。
public static void GetAvailableThreads(out int workerThreads, out int completionPortThreads);

示例代码：

1:   static void SetThreadNumber() {
2:             int worker, io;
3:             //获得线程池默认最大线程数
4:             ThreadPool.GetMaxThreads(out worker,out io);
5:             Console.WriteLine("1、CLR线程池默认最大线程数据,工作者线程数：{0}，IO线程数：{1}",worker,io);
6:             //设置线程池最大线程数
7:             ThreadPool.SetMaxThreads(100,100);
8:             ThreadPool.QueueUserWorkItem(state =>
9:             {
10:                 Thread.Sleep(2000);
11:                 Console.WriteLine("4、线程池线程开始执行异步任务。线程ID：{0}", Thread.CurrentThread.ManagedThreadId);
12:
13:             });
14:             Console.WriteLine("2、自定义设置线程池默认最大线程数据后,工作者线程数：{0}，IO线程数：{1}", worker, io);
15:             //获得最大线程池线程数和当前运行线程数之间的差值。
16:             ThreadPool.GetAvailableThreads(out worker,out io);
17:             Console.WriteLine("3、获得最大线程池线程数和当前运行线程数之间的差值,工作者线程：{0},IO线程：{1}",worker,io);
18:             Console.Read();
19:         }

执行结果：

     线程池的工作者线程是许多异步计算任务所使用的线程，在线程池内部，工作者线程采用先入先出的算法将工作项从线程的全局队列中取出工作项并执行任务。在同一时刻可能有多个工作者线程从全局队列中取出工作项，因此所有工作者线程都会竞争一个线程同步锁，以保证两个或更多工作者线程不会在同一时刻取出工作项。线程池工作者线程数据结构如下图：

            线程工作者线程数据结构图

     线程池在创建工作者线程时，默认会创建ThreadPool.SetMinThreads 方法锁设置的值。如果没有设置这个值，就会创建与应用程序进程允许的使用的CPU数相同的工作者线程，这些工作者线程监视线程池任务的执行情况，得以动态的创建更多或销毁空闲线程。

4.线程执行上下文的流动

    每个线程都有一个执行上下文，执行上下文包涵了安全设置、宿主设置和逻辑调用上下文数据，CLR默认是把初始线程的执行上下文数据向辅助线程流动，初始线程在收集和复制执行上下文数据并传递到辅助线程时会带来性能的损失。如果不需要这些执行上下文数据可以使用 System.Threading.ExecutionContext 类阻止执行上下文数据的流转。常用方法如下：

        // 指示当前是否取消了执行上下文的流动。
        public static bool IsFlowSuppressed();
        // 恢复执行上下文在异步线程之间的流动。
        public static void RestoreFlow();
       //取消执行上下文在异步线程之间的流动。
        public static AsyncFlowControl SuppressFlow();

执行上下文流转控制示例代码：

1:  static void ExecContext() {
2:             //把对象存储在调用逻辑上下文中
3:             System.Runtime.Remoting.Messaging.CallContext.LogicalSetData("Key","这是主线程的执行上下文数据");
4:             Console.WriteLine("主线程执行上下文数据：{0}",System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("Key"));
5:             //阻止主线程执行上下文数据的传递
6:             ExecutionContext.SuppressFlow();
7:             Console.WriteLine("调用SuppressFlow方法以后上下文传递流转是否被阻止：{0}", ExecutionContext.IsFlowSuppressed().ToString());
8:
9:             ThreadPool.QueueUserWorkItem(state => {
10:                 Console.WriteLine("执行上下文数据被阻止传递:{0}",
11:                     System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("Key"));
12:             });
13:
14:             //恢复主线程执行上下文数据的传递
15:             ExecutionContext.RestoreFlow();
16:             Console.WriteLine("调用RestoreFlow方法以后上下文传递流转是否被阻止：{0}", ExecutionContext.IsFlowSuppressed().ToString());
17:
18:             ThreadPool.QueueUserWorkItem(state =>
19:             {
20:                 Console.WriteLine("执行上下文数据没有被阻止传递:{0}",
21:                     System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("Key"));
22:             });
23:             Console.Read();
24:         }

执行结果：

本文简单介绍了CLR 中线程池的基础和使用以及线程池对线程的管理，如果需要构建可伸缩性、高性能、高并发的应用程序，线程池是一种很好的进行这些处理的技术。