C#综合揭秘——细说多线程（上）

桃扇骨 2022-08-04 15:53 167阅读 0赞

引言

本文主要从线程的基础用法，CLR线程池当中工作者线程与I/O线程的开发，并行操作PLINQ等多个方面介绍多线程的开发。  
其中委托的BeginInvoke方法以及回调函数最为常用。  
而 I/O线程可能容易遭到大家的忽略，其实在开发多线程系统，更应该多留意I/O线程的操作。特别是在ASP.NET开发当中，可能更多人只会留意在客户端使用Ajax或者在服务器端使用UpdatePanel。其实合理使用I/O线程在通讯项目或文件下载时，能尽可能地减少IIS的压力。  
并行编程是Framework4.0中极力推广的异步操作方式，更值得更深入地学习。  
希望本篇文章能对各位的学习研究有所帮助，当中有所错漏的地方敬请点评。

[一、线程的定义][Link 1]

[二、线程的基础知识][Link 2]

[三、以ThreadStart方式实现多线程][ThreadStart]

[四、CLR线程池的工作者线程][CLR]

[五、CLR线程池的I/O线程][CLR_I_O]

[六、异步 SqlCommand][SqlCommand]

[七、并行编程与PLINQ][PLINQ]

[八、计时器与锁][Link 3]

**一、线程的定义**

** 1. 1 进程、应用程序域与线程的关系**

进程（Process）是Windows系统中的一个基本概念，它包含着一个运行程序所需要的资源。进程之间是相对独立的，一个进程无法访问另一个进程的数据（除非利用分布式计算方式），一个进程运行的失败也不会影响其他进程的运行，Windows系统就是利用进程把工作划分为多个独立的区域的。进程可以理解为一个程序的基本边界。

应用程序域（AppDomain）是一个程序运行的逻辑区域，它可以视为一个轻量级的进程，.NET的程序集正是在应用程序域中运行的，一个进程可以包含有多个应用程序域，一个应用程序域也可以包含多个程序集。在一个应用程序域中包含了一个或多个上下文context，使用上下文CLR就能够把某些特殊对象的状态放置在不同容器当中。

线程（Thread）是进程中的基本执行单元，在进程入口执行的第一个线程被视为这个进程的主线程。在.NET应用程序中，都是以Main()方法作为入口的，当调用此方法时系统就会自动创建一个主线程。线程主要是由CPU寄存器、调用栈和线程本地存储器（Thread Local Storage，TLS）组成的。CPU寄存器主要记录当前所执行线程的状态，调用栈主要用于维护线程所调用到的内存与数据，TLS主要用于存放线程的状态信息。

进程、应用程序域、线程的关系如下图，一个进程内可以包括多个应用程序域，也有包括多个线程，线程也可以穿梭于多个应用程序域当中。但在同一个时刻，线程只会处于一个应用程序域内。

![2012010713392540.jpg][]

由于本文是以介绍多线程技术为主题，对进程、应用程序域的介绍就到此为止。关于进程、线程、应用程序域的技术，在“[C\#综合揭秘——细说进程、应用程序域与上下文][C]”会有详细介绍。

**1.2 多线程**

在单CPU系统的一个单位时间（time slice）内，CPU只能运行单个线程，运行顺序取决于线程的优先级别。如果在单位时间内线程未能完成执行，系统就会把线程的状态信息保存到线程的本地存储器（TLS） 中，以便下次执行时恢复执行。而多线程只是系统带来的一个假像，它在多个单位时间内进行多个线程的切换。因为切换频密而且单位时间非常短暂，所以多线程可被视作同时运行。

适当使用多线程能提高系统的性能，比如：在系统请求大容量的数据时使用多线程，把数据输出工作交给异步线程，使主线程保持其稳定性去处理其他问题。但需要注意一点，因为CPU需要花费不少的时间在线程的切换上，所以过多地使用多线程反而会导致性能的下降。

[返回目录][Link 4]

**二、线程的基础知识**

**2.1 System.Threading.Thread类**

System.Threading.Thread是用于控制线程的基础类，通过Thread可以控制当前应用程序域中线程的创建、挂起、停止、销毁。

它包括以下常用公共属性：

<table style="width: 600px; font-size: 14px;"> 
 <tbody> 
 <tr> 
 <th>属性名称</th> 
 <th>说明</th> 
 </tr> 
 <tr> 
 <td>CurrentContext</td> 
 <td>获取线程正在其中执行的当前上下文。</td> 
 </tr> 
 <tr> 
 <td>CurrentThread</td> 
 <td>获取当前正在运行的线程。</td> 
 </tr> 
 <tr> 
 <td>ExecutionContext</td> 
 <td>获取一个 ExecutionContext 对象，该对象包含有关当前线程的各种上下文的信息。</td> 
 </tr> 
 <tr> 
 <td>IsAlive</td> 
 <td>获取一个值，该值指示当前线程的执行状态。</td> 
 </tr> 
 <tr> 
 <td>IsBackground</td> 
 <td>获取或设置一个值，该值指示某个线程是否为后台线程。</td> 
 </tr> 
 <tr> 
 <td>IsThreadPoolThread</td> 
 <td>获取一个值，该值指示线程是否属于托管线程池。</td> 
 </tr> 
 <tr> 
 <td>ManagedThreadId</td> 
 <td>获取当前托管线程的唯一标识符。</td> 
 </tr> 
 <tr> 
 <td>Name</td> 
 <td>获取或设置线程的名称。</td> 
 </tr> 
 <tr> 
 <td>Priority</td> 
 <td>获取或设置一个值，该值指示线程的调度优先级。</td> 
 </tr> 
 <tr> 
 <td>ThreadState</td> 
 <td>获取一个值，该值包含当前线程的状态。</td> 
 </tr> 
 </tbody> 
</table>

** **

**2.1.1 线程的标识符**

ManagedThreadId是确认线程的唯一标识符，程序在大部分情况下都是通过Thread.ManagedThreadId来辨别线程的。而Name是一个可变值，在默认时候，Name为一个空值 Null，开发人员可以通过程序设置线程的名称，但这只是一个辅助功能。

** **

**2.1.2 线程的优先级别**

.NET为线程设置了Priority属性来定义线程执行的优先级别，里面包含5个选项，其中Normal是默认值。除非系统有特殊要求，否则不应该随便设置线程的优先级别。

<table style="width: 600px;"> 
 <tbody> 
 <tr> 
 <th>成员名称</th> 
 <th>说明</th> 
 </tr> 
 <tr> 
 <td>Lowest</td> 
 <td> 可以将 Thread 安排在具有任何其他优先级的线程之后。 </td> 
 </tr> 
 <tr> 
 <td>BelowNormal</td> 
 <td> 可以将 Thread 安排在具有 Normal 优先级的线程之后，在具有 Lowest 优先级的线程之前。 </td> 
 </tr> 
 <tr> 
 <td>Normal</td> 
 <td> 默认选择。可以将 Thread 安排在具有 AboveNormal 优先级的线程之后，在具有 BelowNormal 优先级的线程之前。 </td> 
 </tr> 
 <tr> 
 <td>AboveNormal</td> 
 <td> 可以将 Thread 安排在具有 Highest 优先级的线程之后，在具有 Normal 优先级的线程之前。 </td> 
 </tr> 
 <tr> 
 <td>Highest</td> 
 <td> 可以将 Thread 安排在具有任何其他优先级的线程之前。 </td> 
 </tr> 
 </tbody> 
</table>

** **

**2.1.3 线程的状态**

通过ThreadState可以检测线程是处于Unstarted、Sleeping、Running 等等状态，它比 IsAlive 属性能提供更多的特定信息。

前面说过，一个应用程序域中可能包括多个上下文，而通过CurrentContext可以获取线程当前的上下文。

CurrentThread是最常用的一个属性，它是用于获取当前运行的线程。

** **

**2.1.4 System.Threading.Thread的方法**

Thread 中包括了多个方法来控制线程的创建、挂起、停止、销毁，以后来的例子中会经常使用。

<table style="width: 600px; font-size: 14px;"> 
 <tbody> 
 <tr> 
 <th>方法名称</th> 
 <th>说明</th> 
 </tr> 
 <tr> 
 <td>Abort()　　　　</td> 
 <td>终止本线程。</td> 
 </tr> 
 <tr> 
 <td>GetDomain()</td> 
 <td>返回当前线程正在其中运行的当前域。 </td> 
 </tr> 
 <tr> 
 <td>GetDomainId()</td> 
 <td>返回当前线程正在其中运行的当前域Id。</td> 
 </tr> 
 <tr> 
 <td>Interrupt()</td> 
 <td>中断处于 WaitSleepJoin 线程状态的线程。 </td> 
 </tr> 
 <tr> 
 <td>Join()</td> 
 <td>已重载。 阻塞调用线程，直到某个线程终止时为止。 </td> 
 </tr> 
 <tr> 
 <td> Resume()</td> 
 <td>继续运行已挂起的线程。 </td> 
 </tr> 
 <tr> 
 <td>Start()　　</td> 
 <td>执行本线程。</td> 
 </tr> 
 <tr> 
 <td>Suspend()</td> 
 <td>挂起当前线程，如果当前线程已属于挂起状态则此不起作用</td> 
 </tr> 
 <tr> 
 <td>Sleep()　　</td> 
 <td>把正在运行的线程挂起一段时间。</td> 
 </tr> 
 </tbody> 
</table>

**2.1.5 开发实例**

以下这个例子，就是通过Thread显示当前线程信息

![复制代码][copycode.gif]

1         static void Main(string[] args)
     2         {
     3             Thread thread = Thread.CurrentThread;
     4             thread.Name = "Main Thread";
     5             string threadMessage = string.Format("Thread ID:{0}\n    Current AppDomainId:{1}\n    "+
     6                 "Current ContextId:{2}\n    Thread Name:{3}\n    "+
     7                 "Thread State:{4}\n    Thread Priority:{5}\n",
     8                 thread.ManagedThreadId, Thread.GetDomainID(), Thread.CurrentContext.ContextID,
     9                 thread.Name, thread.ThreadState, thread.Priority);
    10             Console.WriteLine(threadMessage);
    11             Console.ReadKey();
    12         }

![复制代码][copycode.gif]

运行结果

![2012010718230274.jpg][]

**2.2  System.Threading 命名空间**

在System.Threading命名空间内提供多个方法来构建多线程应用程序,其中ThreadPool与Thread是多线程开发中最常用到的，在.NET中专门设定了一个CLR线程池专门用于管理线程的运行，这个CLR线程池正是通过ThreadPool类来管理。而Thread是管理线程的最直接方式，下面几节将详细介绍有关内容。

<table style="width: 600px;"> 
 <tbody> 
 <tr> 
 <td style="text-align: center; width: 30%;">类　　　　</td> 
 <td style="text-align: center; width: 70%;">说明</td> 
 </tr> 
 <tr> 
 <td>AutoResetEvent</td> 
 <td>通知正在等待的线程已发生事件。无法继承此类。</td> 
 </tr> 
 <tr> 
 <td>ExecutionContext</td> 
 <td>管理当前线程的执行上下文。无法继承此类。</td> 
 </tr> 
 <tr> 
 <td>Interlocked</td> 
 <td>为多个线程共享的变量提供原子操作。</td> 
 </tr> 
 <tr> 
 <td>Monitor</td> 
 <td>提供同步对对象的访问的机制。</td> 
 </tr> 
 <tr> 
 <td>Mutex</td> 
 <td>一个同步基元，也可用于进程间同步。</td> 
 </tr> 
 <tr> 
 <td>Thread</td> 
 <td>创建并控制线程，设置其优先级并获取其状态。</td> 
 </tr> 
 <tr> 
 <td>ThreadAbortException</td> 
 <td>在对 Abort 方法进行调用时引发的异常。无法继承此类。</td> 
 </tr> 
 <tr> 
 <td>ThreadPool</td> 
 <td>提供一个线程池，该线程池可用于发送工作项、处理异步 I/O、代表其他线程等待以及处理计时器。</td> 
 </tr> 
 <tr> 
 <td>Timeout</td> 
 <td>包含用于指定无限长的时间的常数。无法继承此类。</td> 
 </tr> 
 <tr> 
 <td>Timer</td> 
 <td>提供以指定的时间间隔执行方法的机制。无法继承此类。</td> 
 </tr> 
 <tr> 
 <td>WaitHandle</td> 
 <td>封装等待对共享资源的独占访问的操作系统特定的对象。</td> 
 </tr> 
 </tbody> 
</table>

在System.Threading中的包含了下表中的多个常用委托，其中ThreadStart、ParameterizedThreadStart是最常用到的委托。  
由ThreadStart生成的线程是最直接的方式，但由ThreadStart所生成并不受线程池管理。  
而ParameterizedThreadStart是为异步触发带参数的方法而设的，在下一节将为大家逐一细说。

<table style="width: 600px; font-size: 14px;"> 
 <tbody> 
 <tr> 
 <th style="text-align: center;" align="left">委托</th> 
 <th style="text-align: center;" align="left">说明</th> 
 </tr> 
 <tr> 
 <td>ContextCallback</td> 
 <td>表示要在新上下文中调用的方法。</td> 
 </tr> 
 <tr> 
 <td>ParameterizedThreadStart</td> 
 <td>表示在 Thread 上执行的方法。</td> 
 </tr> 
 <tr> 
 <td>ThreadExceptionEventHandler</td> 
 <td>表示将要处理 Application 的 ThreadException 事件的方法。</td> 
 </tr> 
 <tr> 
 <td>ThreadStart</td> 
 <td>表示在 Thread 上执行的方法。</td> 
 </tr> 
 <tr> 
 <td>TimerCallback</td> 
 <td>表示处理来自 Timer 的调用的方法。</td> 
 </tr> 
 <tr> 
 <td>WaitCallback</td> 
 <td>表示线程池线程要执行的回调方法。</td> 
 </tr> 
 <tr> 
 <td>WaitOrTimerCallback</td> 
 <td>表示当 WaitHandle 超时或终止时要调用的方法。</td> 
 </tr> 
 </tbody> 
</table>

**2.3 线程的管理方式**

通过ThreadStart来创建一个新线程是最直接的方法，但这样创建出来的线程比较难管理，如果创建过多的线程反而会让系统的性能下载。有见及此，.NET为线程管理专门设置了一个CLR线程池，使用CLR线程池系统可以更合理地管理线程的使用。所有请求的服务都能运行于线程池中，当运行结束时线程便会回归到线程池。通过设置，能控制线程池的最大线程数量，在请求超出线程最大值时，线程池能按照操作的优先级别来执行，让部分操作处于等待状态，待有线程回归时再执行操作。

基础知识就为大家介绍到这里，下面将详细介绍多线程的开发。

[返回目录][Link 4]

**三、以ThreadStart方式实现多线程**

**3.1 使用ThreadStart委托**

这里先以一个例子体现一下多线程带来的好处，首先在Message类中建立一个方法ShowMessage()，里面显示了当前运行线程的Id，并使用Thread.Sleep（int ) 方法模拟部分工作。在main()中通过ThreadStart委托绑定Message对象的ShowMessage（）方法，然后通过Thread.Start（）执行异步方法。

![复制代码][copycode.gif]

1 public class Message
 2 {
 3 public void ShowMessage()
 4 {
 5 string message = string.Format("Async threadId is :{0}",
 6 Thread.CurrentThread.ManagedThreadId);
 7 Console.WriteLine(message);
 8 
 9 for (int n = 0; n < 10; n++)
 10 {
 11 Thread.Sleep(300); 
 12 Console.WriteLine("The number is:" + n.ToString()); 
 13 }
 14 }
 15 }
 16 
 17 class Program
 18 {
 19 static void Main(string[] args)
 20 {
 21 Console.WriteLine("Main threadId is:"+
 22 Thread.CurrentThread.ManagedThreadId);
 23 Message message=new Message();
 24 Thread thread = new Thread(new ThreadStart(message.ShowMessage));
 25 thread.Start();
 26 Console.WriteLine("Do something ..........!");
 27 Console.WriteLine("Main thread working is complete!");
 28 
 29 }
 30 }

![复制代码][copycode.gif]

请注意运行结果，在调用Thread.Start()方法后，系统以异步方式运行Message.ShowMessage()，而主线程的操作是继续执行的，在Message.ShowMessage()完成前，主线程已完成所有的操作。

![2012010721572365.jpg][]

**3.2 使用ParameterizedThreadStart委托**

ParameterizedThreadStart委托与ThreadStart委托非常相似，但ParameterizedThreadStart委托是面向带参数方法的。注意ParameterizedThreadStart 对应方法的参数为object，此参数可以为一个值对象，也可以为一个自定义对象。

![复制代码][copycode.gif]

1 public class Person
 2 {
 3 public string Name
 4 {
 5 get;
 6 set;
 7 }
 8 public int Age
 9 {
 10 get;
 11 set;
 12 }
 13 }
 14 
 15 public class Message
 16 {
 17 public void ShowMessage(object person)
 18 {
 19 if (person != null)
 20 {
 21 Person _person = (Person)person;
 22 string message = string.Format("\n{0}'s age is {1}!\nAsync threadId is:{2}",
 23 _person.Name,_person.Age,Thread.CurrentThread.ManagedThreadId);
 24 Console.WriteLine(message);
 25 }
 26 for (int n = 0; n < 10; n++)
 27 {
 28 Thread.Sleep(300); 
 29 Console.WriteLine("The number is:" + n.ToString()); 
 30 }
 31 }
 32 }
 33 
 34 class Program
 35 {
 36 static void Main(string[] args)
 37 { 
 38 Console.WriteLine("Main threadId is:"+Thread.CurrentThread.ManagedThreadId);
 39 
 40 Message message=new Message();
 41 //绑定带参数的异步方法
 42 Thread thread = new Thread(new ParameterizedThreadStart(message.ShowMessage));
 43 Person person = new Person();
 44 person.Name = "Jack";
 45 person.Age = 21;
 46 thread.Start(person); //启动异步线程 
 47 
 48 Console.WriteLine("Do something ..........!");
 49 Console.WriteLine("Main thread working is complete!");
 50 
 51 }
 52 }

![复制代码][copycode.gif]

运行结果：

![2012010722462070.jpg][]

**3.3 前台线程与后台线程**

注意以上两个例子都没有使用Console.ReadKey（）,但系统依然会等待异步线程完成后才会结束。这是因为使用Thread.Start()启动的线程默认为前台线程，而系统必须等待所有前台线程运行结束后，应用程序域才会自动卸载。

在第二节曾经介绍过线程Thread有一个属性IsBackground，通过把此属性设置为true，就可以把线程设置为后台线程！这时应用程序域将在主线程完成时就被卸载，而不会等待异步线程的运行。

**3.4 挂起线程**

为了等待其他后台线程完成后再结束主线程，就可以使用Thread.Sleep()方法。

![复制代码][copycode.gif]

1 public class Message
 2 {
 3 public void ShowMessage()
 4 {
 5 string message = string.Format("\nAsync threadId is:{0}",
 6 Thread.CurrentThread.ManagedThreadId);
 7 Console.WriteLine(message);
 8 for (int n = 0; n < 10; n++)
 9 {
 10 Thread.Sleep(300);
 11 Console.WriteLine("The number is:" + n.ToString());
 12 }
 13 }
 14 }
 15 
 16 class Program
 17 {
 18 static void Main(string[] args)
 19 { 
 20 Console.WriteLine("Main threadId is:"+
 21 Thread.CurrentThread.ManagedThreadId);
 22 
 23 Message message=new Message();
 24 Thread thread = new Thread(new ThreadStart(message.ShowMessage));
 25 thread.IsBackground = true;
 26 thread.Start();
 27 
 28 Console.WriteLine("Do something ..........!");
 29 Console.WriteLine("Main thread working is complete!");
 30 Console.WriteLine("Main thread sleep!");
 31 Thread.Sleep(5000);
 32 }
 33 }

![复制代码][copycode.gif]

运行结果如下，此时应用程序域将在主线程运行5秒后自动结束

![2012010723153675.jpg][]

但系统无法预知异步线程需要运行的时间，所以用通过Thread.Sleep（int）阻塞主线程并不是一个好的解决方法。有见及此，.NET专门为等待异步线程完成开发了另一个方法thread.Join()。把上面例子中的最后一行Thread.Sleep（5000）修改为 thread.Join() 就能保证主线程在异步线程thread运行结束后才会终止。

**3.5 Suspend 与 Resume （慎用）**

Thread.Suspend（）与 Thread.Resume（）是在Framework1.0 就已经存在的老方法了，它们分别可以挂起、恢复线程。但在Framework2.0中就已经明确排斥这两个方法。这是因为一旦某个线程占用了已有的资源，再使用Suspend（）使线程长期处于挂起状态，当在其他线程调用这些资源的时候就会引起死锁！所以在没有必要的情况下应该避免使用这两个方法。

**3.6 终止线程**

若想终止正在运行的线程，可以使用Abort（）方法。在使用Abort（）的时候，将引发一个特殊异常 ThreadAbortException 。  
若想在线程终止前恢复线程的执行，可以在捕获异常后 ,在catch（ThreadAbortException ex）\{...\} 中调用Thread.ResetAbort（）取消终止。  
而使用Thread.Join（）可以保证应用程序域等待异步线程结束后才终止运行。

![复制代码][copycode.gif]

1 static void Main(string[] args)
 2 {
 3 Console.WriteLine("Main threadId is:" +
 4 Thread.CurrentThread.ManagedThreadId);
 5 
 6 Thread thread = new Thread(new ThreadStart(AsyncThread));
 7 thread.IsBackground = true;
 8 thread.Start();
 9 thread.Join();
 10 
 11 } 
 12 
 13 //以异步方式调用
 14 static void AsyncThread()
 15 {
 16 try
 17 {
 18 string message = string.Format("\nAsync threadId is:{0}",
 19 Thread.CurrentThread.ManagedThreadId);
 20 Console.WriteLine(message);
 21 
 22 for (int n = 0; n < 10; n++)
 23 {
 24 //当n等于4时，终止线程
 25 if (n >= 4)
 26 {
 27 Thread.CurrentThread.Abort(n);
 28 }
 29 Thread.Sleep(300);
 30 Console.WriteLine("The number is:" + n.ToString());
 31 }
 32 }
 33 catch (ThreadAbortException ex)
 34 {
 35 //输出终止线程时n的值
 36 if (ex.ExceptionState != null)
 37 Console.WriteLine(string.Format("Thread abort when the number is: {0}!", 
 38 ex.ExceptionState.ToString()));
 39 
 40 //取消终止，继续执行线程
 41 Thread.ResetAbort();
 42 Console.WriteLine("Thread ResetAbort!");
 43 }
 44 
 45 //线程结束
 46 Console.WriteLine("Thread Close!");
 47 }

![复制代码][copycode.gif]

运行结果如下

![2012010919274011.jpg][]

[返回目录][Link 4]

**四、CLR线程池的工作者线程**

**4.1 关于CLR线程池**

使用ThreadStart与ParameterizedThreadStart建立新线程非常简单，但通过此方法建立的线程难于管理，若建立过多的线程反而会影响系统的性能。  
有见及此，.NET引入CLR线程池这个概念。CLR线程池并不会在CLR初始化的时候立刻建立线程，而是在应用程序要创建线程来执行任务时，线程池才初始化一个线程。线程的初始化与其他的线程一样。在完成任务以后，该线程不会自行销毁，而是以挂起的状态返回到线程池。直到应用程序再次向线程池发出请求时，线程池里挂起的线程就会再度激活执行任务。这样既节省了建立线程所造成的性能损耗，也可以让多个任务反复重用同一线程，从而在应用程序生存期内节约大量开销。

*注意*：*通过CLR线程池所建立的线程总是默认为后台线程，优先级数为ThreadPriority.Normal。*

**4.2 工作者线程与I/O线程**

CLR线程池分为工作者线程（workerThreads）与I/O线程 (completionPortThreads) 两种，工作者线程是主要用作管理CLR内部对象的运作，I/O（Input/Output) 线程顾名思义是用于与外部系统交换信息，IO线程的细节将在下一节详细说明。

通过ThreadPool.GetMax（out int workerThreads,out int completionPortThreads )和 ThreadPool.SetMax( int workerThreads, int completionPortThreads)两个方法可以分别读取和设置CLR线程池中工作者线程与I/O线程的最大线程数。在Framework2.0中最大线程默认为25\*CPU数，在Framewok3.0、4.0中最大线程数默认为250\*CPU数，在近年 I3,I5,I7 CPU出现后，线程池的最大值一般默认为1000、2000。  
若想测试线程池中有多少的线程正在投入使用，可以通过ThreadPool.GetAvailableThreads( out int workerThreads,out int completionPortThreads ) 方法。

使用CLR线程池的工作者线程一般有两种方式，一是直接通过 ThreadPool.QueueUserWorkItem() 方法，二是通过委托，下面将逐一细说。

**4.3 通过QueueUserWorkItem启动工作者线程**

ThreadPool线程池中包含有两个静态方法可以直接启动工作者线程：  
一为 ThreadPool.QueueUserWorkItem(WaitCallback)  
二为 ThreadPool.QueueUserWorkItem(WaitCallback,Object)

先把WaitCallback委托指向一个带有Object参数的无返回值方法，再使用 ThreadPool.QueueUserWorkItem(WaitCallback) 就可以异步启动此方法，此时异步方法的参数被视为null 。

![复制代码][copycode.gif]

1     class Program
     2     {
     3         static void Main(string[] args)
     4         {
     5             //把CLR线程池的最大值设置为1000
     6             ThreadPool.SetMaxThreads(1000, 1000);
     7             //显示主线程启动时线程池信息
     8             ThreadMessage("Start");
     9             //启动工作者线程
    10             ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncCallback));
    11             Console.ReadKey();
    12         }
    13         
    14         static void AsyncCallback(object state)
    15         {
    16             Thread.Sleep(200);
    17             ThreadMessage("AsyncCallback");
    18             Console.WriteLine("Async thread do work!");
    19         }
    20 
    21         //显示线程现状
    22         static void ThreadMessage(string data)
    23         {
    24             string message = string.Format("{0}\n  CurrentThreadId is {1}",
    25                  data, Thread.CurrentThread.ManagedThreadId);
    26             Console.WriteLine(message);
    27         }
    28     }

![复制代码][copycode.gif]

运行结果

![2012011313135388.jpg][]

使用 ThreadPool.QueueUserWorkItem(WaitCallback,Object) 方法可以把object对象作为参数传送到回调函数中。  
下面例子中就是把一个string对象作为参数发送到回调函数当中。

![复制代码][copycode.gif]

1     class Program
     2     {
     3         static void Main(string[] args)
     4         {
     5             //把线程池的最大值设置为1000
     6             ThreadPool.SetMaxThreads(1000, 1000);
     7           
     8             ThreadMessage("Start");
     9             ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncCallback),"Hello Elva");
    10             Console.ReadKey();
    11         }
    12 
    13         static void AsyncCallback(object state)
    14         {
    15             Thread.Sleep(200);
    16             ThreadMessage("AsyncCallback");
    17 
    18             string data = (string)state;
    19             Console.WriteLine("Async thread do work!\n"+data);
    20         }
    21 
    22         //显示线程现状
    23         static void ThreadMessage(string data)
    24         {
    25             string message = string.Format("{0}\n  CurrentThreadId is {1}",
    26                  data, Thread.CurrentThread.ManagedThreadId);
    27             Console.WriteLine(message);
    28         }
    29     }

![复制代码][copycode.gif]

运行结果

![2012011313184468.jpg][]

通过ThreadPool.QueueUserWorkItem启动工作者线程虽然是方便，但WaitCallback委托指向的必须是一个带有Object参数的无返回值方法，这无疑是一种限制。若方法需要有返回值，或者带有多个参数，这将多费周折。有见及此，.NET提供了另一种方式去建立工作者线程，那就是委托。

**4.4  委托类**

使用CLR线程池中的工作者线程，最灵活最常用的方式就是使用委托的异步方法，在此先简单介绍一下委托类。

当定义委托后，.NET就会自动创建一个代表该委托的类，下面可以用反射方式显示委托类的方法成员（对反射有兴趣的朋友可以先参考一下“[.NET基础篇——反射的奥妙][.NET]”）

![复制代码][copycode.gif]

1     class Program
     2     {
     3         delegate void MyDelegate();
     4 
     5         static void Main(string[] args)
     6         {
     7             MyDelegate delegate1 = new MyDelegate(AsyncThread);
     8             //显示委托类的几个方法成员     
     9             var methods=delegate1.GetType().GetMethods();
    10             if (methods != null)
    11                 foreach (MethodInfo info in methods)
    12                     Console.WriteLine(info.Name);
    13             Console.ReadKey();
    14          }
    15      }

![复制代码][copycode.gif]

委托类包括以下几个重要方法

![2012011116562025.jpg][]

![复制代码][copycode.gif]

1     public class MyDelegate:MulticastDelegate
    2     {
    3         public MyDelegate(object target, int methodPtr);
    4         //调用委托方法
    5         public virtual void Invoke();
    6         //异步委托
    7         public virtual IAsyncResult BeginInvoke(AsyncCallback callback,object state);
    8         public virtual void EndInvoke(IAsyncResult result);
    9     }

![复制代码][copycode.gif]

当调用Invoke（）方法时，对应此委托的所有方法都会被执行。而BeginInvoke与EndInvoke则支持委托方法的异步调用，由BeginInvoke启动的线程都属于CLR线程池中的工作者线程，在下面将详细说明。

**4.5  利用BeginInvoke与EndInvoke完成异步委托方法**

首先建立一个委托对象，通过IAsyncResult BeginInvoke(string name,AsyncCallback callback,object state) 异步调用委托方法，BeginInvoke 方法除最后的两个参数外，其它参数都是与方法参数相对应的。通过 BeginInvoke 方法将返回一个实现了 System.IAsyncResult 接口的对象，之后就可以利用EndInvoke（IAsyncResult ) 方法就可以结束异步操作，获取委托的运行结果。

![复制代码][copycode.gif]

1     class Program
     2     {
     3         delegate string MyDelegate(string name);
     4 
     5         static void Main(string[] args)
     6         {
     7             ThreadMessage("Main Thread");
     8             
     9             //建立委托
    10             MyDelegate myDelegate = new MyDelegate(Hello);
    11             //异步调用委托，获取计算结果
    12             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
    13             //完成主线程其他工作
    14 ............. 
    15             //等待异步方法完成，调用EndInvoke(IAsyncResult)获取运行结果
    16             string data=myDelegate.EndInvoke(result);
    17             Console.WriteLine(data);
    18             
    19             Console.ReadKey();
    20         }
    21 
    22         static string Hello(string name)
    23         {
    24             ThreadMessage("Async Thread");
    25             Thread.Sleep(2000);            //虚拟异步工作
    26             return "Hello " + name;
    27         }
    28 
    29         //显示当前线程
    30         static void ThreadMessage(string data)
    31         {
    32             string message = string.Format("{0}\n  ThreadId is:{1}",
    33                    data,Thread.CurrentThread.ManagedThreadId);
    34             Console.WriteLine(message);
    35         }
    36     }

![复制代码][copycode.gif]

运行结果

![2012011117481112.jpg][]

**4.6  善用IAsyncResult**

在以上例子中可以看见，如果在使用myDelegate.BeginInvoke后立即调用myDelegate.EndInvoke，那在异步线程未完成工作以前主线程将处于阻塞状态，等到异步线程结束获取计算结果后，主线程才能继续工作，这明显无法展示出多线程的优势。此时可以好好利用IAsyncResult 提高主线程的工作性能，IAsyncResult有以下成员：

![复制代码][copycode.gif]

1 public interface IAsyncResult
    2 {
    3     object AsyncState {
       get;}            //获取用户定义的对象，它限定或包含关于异步操作的信息。
    4     WailHandle AsyncWaitHandle {
       get;}   //获取用于等待异步操作完成的 WaitHandle。
    5     bool CompletedSynchronously {
       get;}  //获取异步操作是否同步完成的指示。
    6     bool IsCompleted {
       get;}             //获取异步操作是否已完成的指示。
    7 }

![复制代码][copycode.gif]

通过轮询方式，使用IsCompleted属性判断异步操作是否完成，这样在异步操作未完成前就可以让主线程执行另外的工作。

![复制代码][copycode.gif]

1     class Program
     2     {
     3         delegate string MyDelegate(string name);
     4 
     5         static void Main(string[] args)
     6         {
     7             ThreadMessage("Main Thread");
     8             
     9             //建立委托
    10             MyDelegate myDelegate = new MyDelegate(Hello);
    11             //异步调用委托，获取计算结果
    12             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
    13             //在异步线程未完成前执行其他工作
    14             while (!result.IsCompleted)
    15             {
    16                 Thread.Sleep(200);      //虚拟操作
    17                 Console.WriteLine("Main thead do work!");
    18             }
    19             string data=myDelegate.EndInvoke(result);
    20             Console.WriteLine(data);
    21             
    22             Console.ReadKey();
    23         }
    24 
    25         static string Hello(string name)
    26         {
    27             ThreadMessage("Async Thread");
    28             Thread.Sleep(2000);
    29             return "Hello " + name;
    30         }
    31 
    32         static void ThreadMessage(string data)
    33         {
    34             string message = string.Format("{0}\n  ThreadId is:{1}",
    35                    data,Thread.CurrentThread.ManagedThreadId);
    36             Console.WriteLine(message);
    37         }
    38     }

![复制代码][copycode.gif]

运行结果：

![2012011118580960.jpg][]

除此以外，也可以使用WailHandle完成同样的工作，WaitHandle里面包含有一个方法WaitOne（int timeout），它可以判断委托是否完成工作，在工作未完成前主线程可以继续其他工作。运行下面代码可得到与使用 IAsyncResult.IsCompleted 同样的结果，而且更简单方便 。

![复制代码][copycode.gif]

1 namespace Test
     2 {
     3     class Program
     4     {
     5         delegate string MyDelegate(string name);
     6 
     7         static void Main(string[] args)
     8         {
     9             ThreadMessage("Main Thread");
    10             
    11             //建立委托
    12             MyDelegate myDelegate = new MyDelegate(Hello);
    13  
    14             //异步调用委托，获取计算结果
    15             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
    16             
    17             while (!result.AsyncWaitHandle.WaitOne(200))
    18             {
    19                 Console.WriteLine("Main thead do work!");
    20             }
    21             string data=myDelegate.EndInvoke(result);
    22             Console.WriteLine(data);
    23             
    24             Console.ReadKey();
    25         }
    26 
    27         static string Hello(string name)
    28         {
    29             ThreadMessage("Async Thread");
    30             Thread.Sleep(2000);
    31             return "Hello " + name;
    32         }
    33 
    34         static void ThreadMessage(string data)
    35         {
    36             string message = string.Format("{0}\n  ThreadId is:{1}",
    37                    data,Thread.CurrentThread.ManagedThreadId);
    38             Console.WriteLine(message);
    39         }
    40     }

![复制代码][copycode.gif]

当要监视多个运行对象的时候，使用IAsyncResult.WaitHandle.WaitOne可就派不上用场了。  
幸好.NET为WaitHandle准备了另外两个静态方法：WaitAny（waitHandle\[\], int）与WaitAll (waitHandle\[\] , int)。  
其中WaitAll在等待所有waitHandle完成后再返回一个bool值。  
而WaitAny是等待其中一个waitHandle完成后就返回一个int，这个int是代表已完成waitHandle在waitHandle\[\]中的数组索引。  
下面就是使用WaitAll的例子，运行结果与使用 IAsyncResult.IsCompleted 相同。

![复制代码][copycode.gif]

1     class Program
     2     {
     3         delegate string MyDelegate(string name);
     4 
     5         static void Main(string[] args)
     6         {
     7             ThreadMessage("Main Thread");
     8             
     9             //建立委托
    10             MyDelegate myDelegate = new MyDelegate(Hello);
    11  
    12             //异步调用委托，获取计算结果
    13             IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
    14 
    15             //此处可加入多个检测对象
    16             WaitHandle[] waitHandleList = new WaitHandle[] { result.AsyncWaitHandle,........ };
    17             while (!WaitHandle.WaitAll(waitHandleList,200))
    18             {
    19                 Console.WriteLine("Main thead do work!");
    20             }
    21             string data=myDelegate.EndInvoke(result);
    22             Console.WriteLine(data);
    23             
    24             Console.ReadKey();
    25         }
    26 
    27         static string Hello(string name)
    28         {
    29             ThreadMessage("Async Thread");
    30             Thread.Sleep(2000);
    31             return "Hello " + name;
    32         }
    33 
    34         static void ThreadMessage(string data)
    35         {
    36             string message = string.Format("{0}\n  ThreadId is:{1}",
    37                    data,Thread.CurrentThread.ManagedThreadId);
    38             Console.WriteLine(message);
    39         }
    40     }

![复制代码][copycode.gif]

**4.7 回调函数**

使用轮询方式来检测异步方法的状态非常麻烦，而且效率不高，有见及此，.NET为 IAsyncResult BeginInvoke（AsyncCallback , object）准备了一个回调函数。使用 AsyncCallback 就可以绑定一个方法作为回调函数，回调函数必须是带参数 IAsyncResult 且无返回值的方法： void AsycnCallbackMethod(IAsyncResult result) 。在BeginInvoke方法完成后，系统就会调用AsyncCallback所绑定的回调函数,最后回调函数中调用 XXX EndInvoke（IAsyncResult result) 就可以结束异步方法，它的返回值类型与委托的返回值一致。

![复制代码][copycode.gif]

1 class Program
 2 {
 3 delegate string MyDelegate(string name);
 4 
 5 static void Main(string[] args)
 6 {
 7 ThreadMessage("Main Thread");
 8 
 9 //建立委托
 10 MyDelegate myDelegate = new MyDelegate(Hello);
 11 //异步调用委托，获取计算结果
 12 myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), null);
 13 //在启动异步线程后，主线程可以继续工作而不需要等待
 14 for (int n = 0; n < 6; n++)
 15 Console.WriteLine(" Main thread do work!");
 16 Console.WriteLine("");
 17 
 18 Console.ReadKey();
 19 }
 20 
 21 static string Hello(string name)
 22 {
 23 ThreadMessage("Async Thread");
 24 Thread.Sleep(2000); \\模拟异步操作
 25 return "\nHello " + name;
 26 }
 27 
 28 static void Completed(IAsyncResult result)
 29 {
 30 ThreadMessage("Async Completed");
 31 
 32 //获取委托对象，调用EndInvoke方法获取运行结果
 33 AsyncResult _result = (AsyncResult)result;
 34 MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
 35 string data = myDelegate.EndInvoke(_result);
 36 Console.WriteLine(data);
 37 }
 38 
 39 static void ThreadMessage(string data)
 40 {
 41 string message = string.Format("{0}\n ThreadId is:{1}",
 42 data, Thread.CurrentThread.ManagedThreadId);
 43 Console.WriteLine(message);
 44 }
 45 }

![复制代码][copycode.gif]

可以看到，主线在调用BeginInvoke方法可以继续执行其他命令，而无需再等待了，这无疑比使用轮询方式判断异步方法是否完成更有优势。  
在异步方法执行完成后将会调用AsyncCallback所绑定的回调函数，注意一点，回调函数依然是在异步线程中执行，这样就不会影响主线程的运行，这也使用回调函数最值得青昧的地方。  
在回调函数中有一个既定的参数IAsyncResult,把IAsyncResult强制转换为AsyncResult后，就可以通过 AsyncResult.AsyncDelegate 获取原委托，再使用EndInvoke方法获取计算结果。  
运行结果如下：

![2012011323313036.jpg][]

如果想为回调函数传送一些外部信息，就可以利用BeginInvoke(AsyncCallback,object)的最后一个参数object,它允许外部向回调函数输入任何类型的参数。只需要在回调函数中利用 AsyncResult.AsyncState 就可以获取object对象。

![复制代码][copycode.gif]

1 class Program
 2 {
 3 public class Person
 4 {
 5 public string Name;
 6 public int Age;
 7 }
 8 
 9 delegate string MyDelegate(string name);
 10 
 11 static void Main(string[] args)
 12 {
 13 ThreadMessage("Main Thread");
 14 
 15 //建立委托
 16 MyDelegate myDelegate = new MyDelegate(Hello);
 17 
 18 //建立Person对象
 19 Person person = new Person();
 20 person.Name = "Elva";
 21 person.Age = 27;
 22 
 23 //异步调用委托，输入参数对象person, 获取计算结果
 24 myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), person); 
 25 
 26 //在启动异步线程后，主线程可以继续工作而不需要等待
 27 for (int n = 0; n < 6; n++)
 28 Console.WriteLine(" Main thread do work!");
 29 Console.WriteLine("");
 30 
 31 Console.ReadKey();
 32 }
 33 
 34 static string Hello(string name)
 35 {
 36 ThreadMessage("Async Thread");
 37 Thread.Sleep(2000);
 38 return "\nHello " + name;
 39 }
 40 
 41 static void Completed(IAsyncResult result)
 42 {
 43 ThreadMessage("Async Completed");
 44 
 45 //获取委托对象，调用EndInvoke方法获取运行结果
 46 AsyncResult _result = (AsyncResult)result;
 47 MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
 48 string data = myDelegate.EndInvoke(_result);
 49 //获取Person对象
 50 Person person = (Person)result.AsyncState;
 51 string message = person.Name + "'s age is " + person.Age.ToString();
 52 
 53 Console.WriteLine(data+"\n"+message);
 54 }
 55 
 56 static void ThreadMessage(string data)
 57 {
 58 string message = string.Format("{0}\n ThreadId is:{1}",
 59 data, Thread.CurrentThread.ManagedThreadId);
 60 Console.WriteLine(message);
 61 }
 62 }

![复制代码][copycode.gif]

运行结果:

![2012011323434221.jpg][]

关于I/O线程、SqlCommand多线程查询、PLINQ、定时器与锁的内容将在[C\#综合揭秘——细说多线程（下）][C 1]中详细介绍。  
对 .NET 开发有兴趣的朋友欢迎加入QQ群：[230564952 ][230564952] 共同探讨 ！

[Link 1]: http://www.cnblogs.com/leslies2/archive/2012/02/07/2310495.html#t1
[Link 2]: http://www.cnblogs.com/leslies2/archive/2012/02/07/2310495.html#t2
[ThreadStart]: http://www.cnblogs.com/leslies2/archive/2012/02/07/2310495.html#t3
[CLR]: http://www.cnblogs.com/leslies2/archive/2012/02/07/2310495.html#t4
[CLR_I_O]: http://www.cnblogs.com/leslies2/archive/2012/02/08/2320914.html#t5
[SqlCommand]: http://www.cnblogs.com/leslies2/archive/2012/02/08/2320914.html#t6
[PLINQ]: http://www.cnblogs.com/leslies2/archive/2012/02/08/2320914.html#t7
[Link 3]: http://www.cnblogs.com/leslies2/archive/2012/02/08/2320914.html#t8
[2012010713392540.jpg]: /images/20220731/0a3f6c5d42044f689fef98c87d21252d.png
[C]: http://www.cnblogs.com/leslies2/archive/2012/03/06/2379235.html
[Link 4]: http://www.cnblogs.com/leslies2/archive/2012/02/07/2310495.html#t0
[copycode.gif]: /images/20220731/2407e757a1054a91a18d628d663ac797.png
[2012010718230274.jpg]: /images/20220731/a410eb85e1574677872c444ff6290e13.png
[2012010721572365.jpg]: /images/20220731/3ba6b420de3a4888b467facbf67e509c.png
[2012010722462070.jpg]: /images/20220731/47bf5b6c81ae4d66813ede5efe00bc08.png
[2012010723153675.jpg]: /images/20220731/52bc2c483ae44fbb82d8f630f91d2f78.png
[2012010919274011.jpg]: /images/20220731/e937ddb8b2694072b569385277f5d626.png
[2012011313135388.jpg]: /images/20220731/e88be3c1381e4215a9590c2b32557d79.png
[2012011313184468.jpg]: /images/20220731/447bebafa6814486952637a6f033c8ed.png
[.NET]: http://www.cnblogs.com/leslies2/archive/2011/11/22/2257703.html
[2012011116562025.jpg]: /images/20220731/c4571ffd42d24c82ab45d18e36a96f6c.png
[2012011117481112.jpg]: /images/20220731/065ae12937c0430fb0de05a469da7e3f.png
[2012011118580960.jpg]: /images/20220731/d0671f9fb96c4a8fa93dc361ecc35cb8.png
[2012011323313036.jpg]: /images/20220731/4fafabb452be4cb3902c99297fe6e18c.png
[2012011323434221.jpg]: /images/20220731/4f0f678d24044861b73d0cb2af839668.png
[C 1]: http://www.cnblogs.com/leslies2/archive/2012/02/08/2320914.html
[230564952]: http://qun.qq.com/#jointhegroup/gid/230564952