1. C#综合揭秘——细说多线程(上)
2. 一、线程的定义
2.1.1. 1.1 进程、应用程序域与线程的关系
进程(Process)是 Windows 系统中的一个基本概念，它包含着一个运行程序所需要的资源。进程之间是相对独立的，一个进程无法访问另一个进程的数据(除非利用分布式计算方式)，一个进程运行的失败也不会影响其他进程的运行，Windows 系统就是利用进程把工作划分为多个独立的区域的。进程可以理解为一个程序的基本边界。
应用程序域(AppDomain)是一个程序运行的逻辑区域，它可以视为一个轻量级的进程，.NET 的程序集正是在应用程序域中运行的，一个进程可以包含有多个应用程序域，一个应用程序域也可以包含多个程序集。在一个应用程序域中包含了一个或多个上下文 context，使用上下文 CLR 就能够把某些特殊对象的状态放置在不同容器当中。
线程(Thread)是进程中的基本执行单元，在进程入口执行的第一个线程被视为这个进程的主线程。在.NET 应用程序中，都是以 Main()方法作为入口的，当调用此方法时系统就会自动创建一个主线程。线程主要是由 CPU 寄存器、调用栈和线程本地存储器(Thread Local Storage，TLS)组成的。CPU 寄存器主要记录当前所执行线程的状态，调用栈主要用于维护线程所调用到的内存与数据，TLS 主要用于存放线程的状态信息。
进程、应用程序域、线程的关系如下图，一个进程内可以包括多个应用程序域，也有包括多个线程，线程也可以穿梭于多个应用程序域当中。但在同一个时刻，线程只会处于一个应用程序域内。
由于本文是以介绍多线程技术为主题，对进程、应用程序域的介绍就到此为止。关于进程、线程、应用程序域的技术，在“C#综合揭秘——细说进程、应用程序域与上下文”会有详细介绍。
2.1.2. 1.2 多线程
在单 CPU 系统的一个单位时间(time slice)内，CPU 只能运行单个线程，运行顺序取决于线程的优先级别。如果在单位时间内线程未能完成执行，系统就会把线程的状态信息保存到线程的本地存储器(TLS) 中，以便下次执行时恢复执行。而多线程只是系统带来的一个假像，它在多个单位时间内进行多个线程的切换。因为切换频密而且单位时间非常短暂，所以多线程可被视作同时运行。
适当使用多线程能提高系统的性能，比如：在系统请求大容量的数据时使用多线程，把数据输出工作交给异步线程，使主线程保持其稳定性去处理其他问题。但需要注意一点，因为 CPU 需要花费不少的时间在线程的切换上，所以过多地使用多线程反而会导致性能的下降。
3. 二、线程的基础知识
3.1.1. 2.1 System.Threading.Thread 类
System.Threading.Thread 是用于控制线程的基础类，通过 Thread 可以控制当前应用程序域中线程的创建、挂起、停止、销毁。
它包括以下常用公共属性：
| 属性名称 | 说明 |
|---|---|
| CurrentContext | 获取线程正在其中执行的当前上下文。 |
| CurrentThread | 获取当前正在运行的线程。 |
| ExecutionContext | 获取一个 ExecutionContext 对象，该对象包含有关当前线程的各种上下文的信息。 |
| IsAlive | 获取一个值，该值指示当前线程的执行状态。 |
| IsBackground | 获取或设置一个值，该值指示某个线程是否为后台线程。 |
| IsThreadPoolThread | 获取一个值，该值指示线程是否属于托管线程池。 |
| ManagedThreadId | 获取当前托管线程的唯一标识符。 |
| Name | 获取或设置线程的名称。 |
| Priority | 获取或设置一个值，该值指示线程的调度优先级。 |
| ThreadState | 获取一个值，该值包含当前线程的状态。 |
3.1.2. 2.1.1 线程的标识符
ManagedThreadId 是确认线程的唯一标识符，程序在大部分情况下都是通过 Thread.ManagedThreadId 来辨别线程的。而 Name 是一个可变值，在默认时候，Name 为一个空值 Null，开发人员可以通过程序设置线程的名称，但这只是一个辅助功能。
3.1.3. 2.1.2 线程的优先级别
.NET 为线程设置了 Priority 属性来定义线程执行的优先级别，里面包含 5 个选项，其中 Normal 是默认值。除非系统有特殊要求，否则不应该随便设置线程的优先级别。
| 成员名称 | 说明 |
|---|---|
| Lowest | 可以将 Thread 安排在具有任何其他优先级的线程之后。 |
| BelowNormal | 可以将 Thread 安排在具有 Normal 优先级的线程之后，在具有 Lowest 优先级的线程之前。 |
| Normal | 默认选择。可以将 Thread 安排在具有 AboveNormal 优先级的线程之后，在具有 BelowNormal 优先级的线程之前。 |
| AboveNormal | 可以将 Thread 安排在具有 Highest 优先级的线程之后，在具有 Normal 优先级的线程之前。 |
| Highest | 可以将 Thread 安排在具有任何其他优先级的线程之前。 |
3.1.4. 2.1.3 线程的状态
通过 ThreadState 可以检测线程是处于 Unstarted、Sleeping、Running 等等状态，它比 IsAlive 属性能提供更多的特定信息。
前面说过，一个应用程序域中可能包括多个上下文，而通过 CurrentContext 可以获取线程当前的上下文。
CurrentThread 是最常用的一个属性，它是用于获取当前运行的线程。
3.1.5. 2.1.4 System.Threading.Thread 的方法
Thread 中包括了多个方法来控制线程的创建、挂起、停止、销毁，以后来的例子中会经常使用。
| 方法名称 | 说明 |
|---|---|
| Abort() | 终止本线程。 |
| GetDomain() | 返回当前线程正在其中运行的当前域。 |
| GetDomainId() | 返回当前线程正在其中运行的当前域 Id。 |
| Interrupt() | 中断处于 WaitSleepJoin 线程状态的线程。 |
| Join() | 已重载。 阻塞调用线程，直到某个线程终止时为止。 |
| Resume() | 继续运行已挂起的线程。 |
| Start() | 执行本线程。 |
| Suspend() | 挂起当前线程，如果当前线程已属于挂起状态则此不起作用 |
| Sleep() | 把正在运行的线程挂起一段时间。 |
3.1.6. 2.1.5 开发实例
以下这个例子，就是通过 Thread 显示当前线程信息
static void Main(string[] args) {
Thread thread = Thread.CurrentThread;
thread.Name = "Main Thread";
string threadMessage = string.Format("Thread ID:{0}\n Current AppDomainId:{1}\n " +
"Current ContextId:{2}\n Thread Name:{3}\n " +
"Thread State:{4}\n Thread Priority:{5}\n",
thread.ManagedThreadId, Thread.GetDomainID(), Thread.CurrentContext.ContextID,
thread.Name, thread.ThreadState, thread.Priority);
Console.WriteLine(threadMessage);
Console.ReadKey();
}
运行结果
3.1.7. 2.2 System.Threading 命名空间
在 System.Threading 命名空间内提供多个方法来构建多线程应用程序,其中 ThreadPool 与 Thread 是多线程开发中最常用到的，在.NET 中专门设定了一个 CLR 线程池专门用于管理线程的运行，这个 CLR 线程池正是通过 ThreadPool 类来管理。而 Thread 是管理线程的最直接方式，下面几节将详细介绍有关内容。
| 类 | 说明 |
|---|---|
| AutoResetEvent | 通知正在等待的线程已发生事件。无法继承此类。 |
| ExecutionContext | 管理当前线程的执行上下文。无法继承此类。 |
| Interlocked | 为多个线程共享的变量提供原子操作。 |
| Monitor | 提供同步对对象的访问的机制。 |
| Mutex | 一个同步基元，也可用于进程间同步。 |
| Thread | 创建并控制线程，设置其优先级并获取其状态。 |
| ThreadAbortException | 在对 Abort 方法进行调用时引发的异常。无法继承此类。 |
| ThreadPool | 提供一个线程池，该线程池可用于发送工作项、处理异步 I/O、代表其他线程等待以及处理计时器。 |
| Timeout | 包含用于指定无限长的时间的常数。无法继承此类。 |
| Timer | 提供以指定的时间间隔执行方法的机制。无法继承此类。 |
| WaitHandle | 封装等待对共享资源的独占访问的操作系统特定的对象。 |
在 System.Threading 中的包含了下表中的多个常用委托，其中 ==ThreadStart、ParameterizedThreadStart 是最常用到的委托。== 由 ThreadStart 生成的线程是最直接的方式，但由 ThreadStart所生成并不受线程池管理。而 ParameterizedThreadStart 是为异步触发带参数的方法而设的，在下一节将为大家逐一细说。
| 委托 | 说明 |
|---|---|
| ContextCallback | 表示要在新上下文中调用的方法。 |
| ParameterizedThreadStart | 表示在 Thread 上执行的方法。 |
| ThreadExceptionEventHandler | 表示将要处理 Application 的 ThreadException 事件的方法。 |
| ThreadStart | 表示在 Thread 上执行的方法。 |
| TimerCallback | 表示处理来自 Timer 的调用的方法。 |
| WaitCallback | 表示线程池线程要执行的回调方法。 |
| WaitOrTimerCallback | 表示当 WaitHandle 超时或终止时要调用的方法。 |
3.1.8. 2.3 线程的管理方式
==通过 ThreadStart 来创建一个新线程是最直接的方法，但这样创建出来的线程比较难管理，如果创建过多的线程反而会让系统的性能下载。== 有见及此，.NET 为线程管理专门设置了一个 CLR 线程池，使用 CLR 线程池系统可以更合理地管理线程的使用。所有请求的服务都能运行于线程池中，当运行结束时线程便会回归到线程池。通过设置，能控制线程池的最大线程数量，在请求超出线程最大值时，线程池能按照操作的优先级别来执行，让部分操作处于等待状态，待有线程回归时再执行操作。
4. 三、以 ThreadStart 方式实现多线程
4.1.1. 3.1 使用 ThreadStart 委托
这里先以一个例子体现一下多线程带来的好处，首先在 Message 类中建立一个方法 ShowMessage()，里面显示了当前运行线程的 Id，并使用 Thread.Sleep 方法模拟部分工作。在 main() 中通过 ThreadStart 委托绑定 Message 对象的 ShowMessage 方法，然后通过 Thread.Start 执行异步方法。
public class Message {
public void ShowMessage() {
string message = string.Format("Async threadId is :{0}",
Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
for (int n = 0; n < 10; n++) {
Thread.Sleep(300);
Console.WriteLine("The number is:" + n.ToString());
}
}
}
class Program {
static void Main(string[] args) {
Console.WriteLine("Main threadId is:" +
Thread.CurrentThread.ManagedThreadId);
Message message = new Message();
Thread thread = new Thread(new ThreadStart(message.ShowMessage));
thread.Start();
Console.WriteLine("Do something ..........!");
Console.WriteLine("Main thread working is complete!");
}
}
请注意运行结果，在调用 Thread.Start()方法后，系统以异步方式运行 Message.ShowMessage()，而主线程的操作是继续执行的，在 Message.ShowMessage()完成前，主线程已完成所有的操作。
4.1.2. 3.2 使用 ParameterizedThreadStart 委托
ParameterizedThreadStart 委托与 ThreadStart 委托非常相似，但 ParameterizedThreadStart 委托是面向带参数方法的。注意 ParameterizedThreadStart 对应方法的参数为 object，此参数可以为一个值对象，也可以为一个自定义对象。
public class Person {
public string Name {
get;
set;
}
public int Age {
get;
set;
}
}
public class Message {
public void ShowMessage(object person) {
if (person != null) {
Person _person = (Person) person;
string message = string.Format("\n{0}'s age is {1}!\nAsync threadId is:{2}",
_person.Name, _person.Age, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
for (int n = 0; n < 10; n++) {
Thread.Sleep(300);
Console.WriteLine("The number is:" + n.ToString());
}
}
}
class Program {
static void Main(string[] args) {
Console.WriteLine("Main threadId is:" + Thread.CurrentThread.ManagedThreadId);
Message message = new Message();
//绑定带参数的异步方法
Thread thread = new Thread(new ParameterizedThreadStart(message.ShowMessage));
Person person = new Person();
person.Name = "Jack";
person.Age = 21;
thread.Start(person); //启动异步线程
Console.WriteLine("Do something ..........!");
Console.WriteLine("Main thread working is complete!");
}
}
运行结果：
4.1.3. 3.3 前台线程与后台线程
注意以上两个例子都没有使用 Console.ReadKey(),但系统依然会等待异步线程完成后才会结束。这是因为使用 Thread.Start()启动的线程默认为前台线程，而系统必须等待所有前台线程运行结束后，应用程序域才会自动卸载。
在第二节曾经介绍过线程 Thread 有一个属性 IsBackground，通过把此属性设置为 true，就可以把线程设置为后台线程！这时应用程序域将在主线程完成时就被卸载，而不会等待异步线程的运行。
4.1.4. 3.4 挂起线程
为了等待其他后台线程完成后再结束主线程，就可以使用 Thread.Sleep()方法。
public class Message {
public void ShowMessage() {
string message = string.Format("\nAsync threadId is:{0}",
Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
for (int n = 0; n < 10; n++) {
Thread.Sleep(300);
Console.WriteLine("The number is:" + n.ToString());
}
}
}
class Program {
static void Main(string[] args) {
Console.WriteLine("Main threadId is:" +
Thread.CurrentThread.ManagedThreadId);
Message message = new Message();
Thread thread = new Thread(new ThreadStart(message.ShowMessage));
thread.IsBackground = true;
thread.Start();
Console.WriteLine("Do something ..........!");
Console.WriteLine("Main thread working is complete!");
Console.WriteLine("Main thread sleep!");
Thread.Sleep(5000);
}
}
运行结果如下，此时应用程序域将在主线程运行 5 秒后自动结束
但系统无法预知异步线程需要运行的时间，所以用通过 Thread.Sleep(int)阻塞主线程并不是一个好的解决方法。有见及此，.NET 专门为等待异步线程完成开发了另一个方法 thread.Join()。把上面例子中的最后一行 Thread.Sleep(5000)修改为 thread.Join() 就能保证主线程在异步线程 thread 运行结束后才会终止。
4.1.5. 3.5 Suspend 与 Resume (慎用)
Thread.Suspend()与 Thread.Resume()是在 Framework1.0 就已经存在的老方法了，它们分别可以挂起、恢复线程。但在 Framework2.0 中就已经明确排斥这两个方法。这是因为一旦某个线程占用了已有的资源，再使用 Suspend()使线程长期处于挂起状态，当在其他线程调用这些资源的时候就会引起死锁！所以在没有必要的情况下应该避免使用这两个方法。
4.1.6. 3.6 终止线程
若想终止正在运行的线程，可以使用 Abort()方法。在使用 Abort()的时候，将引发一个特殊异常 ThreadAbortException 。若想在线程终止前恢复线程的执行，可以在捕获异常后 ,在 catch(ThreadAbortException ex){...} 中调用 Thread.ResetAbort()取消终止。而使用 Thread.Join()可以保证应用程序域等待异步线程结束后才终止运行。
static void Main(string[] args) {
Console.WriteLine("Main threadId is:" +
Thread.CurrentThread.ManagedThreadId);
Thread thread = new Thread(new ThreadStart(AsyncThread));
thread.IsBackground = true;
thread.Start();
thread.Join();
}
//以异步方式调用
static void AsyncThread() {
try {
string message = string.Format("\nAsync threadId is:{0}",
Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
for (int n = 0; n < 10; n++) {
//当n等于4时，终止线程
if (n >= 4) {
Thread.CurrentThread.Abort(n);
}
Thread.Sleep(300);
Console.WriteLine("The number is:" + n.ToString());
}
} catch (ThreadAbortException ex) {
//输出终止线程时n的值
if (ex.ExceptionState != null)
Console.WriteLine(string.Format("Thread abort when the number is: {0}!",
ex.ExceptionState.ToString()));
//取消终止，继续执行线程
Thread.ResetAbort();
Console.WriteLine("Thread ResetAbort!");
}
//线程结束
Console.WriteLine("Thread Close!");
}
运行结果如下
5. 四、CLR 线程池的工作者线程
5.1.1. 4.1 关于 CLR 线程池
==使用 ThreadStart 与 ParameterizedThreadStart 建立新线程非常简单，但通过此方法建立的线程难于管理，若建立过多的线程反而会影响系统的性能。== 有见及此，.NET 引入 CLR 线程池这个概念。CLR 线程池并不会在 CLR 初始化的时候立刻建立线程，而是在应用程序要创建线程来执行任务时，线程池才初始化一个线程。线程的初始化与其他的线程一样。在完成任务以后，该线程不会自行销毁，而是以挂起的状态返回到线程池。直到应用程序再次向线程池发出请求时，线程池里挂起的线程就会再度激活执行任务。这样既节省了建立线程所造成的性能损耗，也可以让多个任务反复重用同一线程，从而在应用程序生存期内节约大量开销。
注意：通过 CLR 线程池所建立的线程总是默认为后台线程，优先级数为 ThreadPriority.Normal。
5.1.2. 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 中最大线程默认为 25CPU 数，在 Framewok3.0、4.0 中最大线程数默认为 250CPU 数，在近年 I3,I5,I7 CPU 出现后，线程池的最大值一般默认为 1000、2000。若想测试线程池中有多少的线程正在投入使用，可以通过 ThreadPool.GetAvailableThreads( out int workerThreads,out int completionPortThreads ) 方法。
使用 CLR 线程池的工作者线程一般有两种方式，一是直接通过 ThreadPool.QueueUserWorkItem() 方法，二是通过委托，下面将逐一细说。
5.1.3. 4.3 通过 QueueUserWorkItem 启动工作者线程
ThreadPool 线程池中包含有两个静态方法可以直接启动工作者线程：一为 ThreadPool.QueueUserWorkItem(WaitCallback) 二为 ThreadPool.QueueUserWorkItem(WaitCallback, Object)
先把 WaitCallback 委托指向一个带有 Object 参数的无返回值方法，再使用 ThreadPool.QueueUserWorkItem(WaitCallback) 就可以异步启动此方法，此时异步方法的参数被视为 null 。
class Program {
static void Main(string[] args) {
//把CLR线程池的最大值设置为1000
ThreadPool.SetMaxThreads(1000, 1000);
//显示主线程启动时线程池信息
ThreadMessage("Start");
//启动工作者线程
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncCallback));
Console.ReadKey();
}
static void AsyncCallback(object state) {
Thread.Sleep(200);
ThreadMessage("AsyncCallback");
Console.WriteLine("Async thread do work!");
}
//显示线程现状
static void ThreadMessage(string data) {
string message = string.Format("{0}\n CurrentThreadId is {1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}
运行结果
使用 ThreadPool.QueueUserWorkItem(WaitCallback, Object) 方法可以把 object 对象作为参数传送到回调函数中。下面例子中就是把一个 string 对象作为参数发送到回调函数当中。
class Program {
static void Main(string[] args) {
//把线程池的最大值设置为1000
ThreadPool.SetMaxThreads(1000, 1000);
ThreadMessage("Start");
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncCallback), "Hello Elva");
Console.ReadKey();
}
static void AsyncCallback(object state) {
Thread.Sleep(200);
ThreadMessage("AsyncCallback");
string data = (string) state;
Console.WriteLine("Async thread do work!\n" + data);
}
//显示线程现状
static void ThreadMessage(string data) {
string message = string.Format("{0}\n CurrentThreadId is {1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}
运行结果
==通过 ThreadPool.QueueUserWorkItem 启动工作者线程虽然是方便，但 WaitCallback 委托指向的必须是一个带有 Object 参数的无返回值方法，这无疑是一种限制。== 若方法需要有返回值，或者带有多个参数，这将多费周折。有见及此，.NET 提供了另一种方式去建立工作者线程，那就是委托。
5.1.4. 4.4 委托类
使用 CLR 线程池中的工作者线程，最灵活最常用的方式就是使用委托的异步方法，在此先简单介绍一下委托类。
当定义委托后，.NET 就会自动创建一个代表该委托的类，下面可以用反射方式显示委托类的方法成员(对反射有兴趣的朋友可以先参考一下“.NET 基础篇——反射的奥妙”)
class Program {
delegate void MyDelegate();
static void Main(string[] args) {
MyDelegate delegate1 = new MyDelegate(AsyncThread);
//显示委托类的几个方法成员
var methods = delegate1.GetType().GetMethods();
if (methods != null)
foreach(MethodInfo info in methods)
Console.WriteLine(info.Name);
Console.ReadKey();
}
}
委托类包括以下几个重要方法
public class MyDelegate: MulticastDelegate {
public MyDelegate(object target, int methodPtr);
//调用委托方法
public virtual void Invoke();
//异步委托
public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object state);
public virtual void EndInvoke(IAsyncResult result);
}
当调用 Invoke() 方法时，对应此委托的所有方法都会被执行。而 BeginInvoke 与 EndInvoke 则支持委托方法的异步调用，由 BeginInvoke 启动的线程都属于 CLR 线程池中的工作者线程，在下面将详细说明。
5.1.5. 4.5 利用 BeginInvoke 与 EndInvoke 完成异步委托方法
首先建立一个委托对象，通过 IAsyncResult BeginInvoke(string name,AsyncCallback callback,object state) 异步调用委托方法，BeginInvoke 方法除最后的两个参数外，其它参数都是与方法参数相对应的。通过 BeginInvoke 方法将返回一个实现了 System.IAsyncResult 接口的对象，之后就可以利用 EndInvoke(IAsyncResult) 方法就可以结束异步操作，获取委托的运行结果。
class Program {
delegate string MyDelegate(string name);
static void Main(string[] args) {
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//异步调用委托，获取计算结果
IAsyncResult result = myDelegate.BeginInvoke("Leslie", null, null);
//完成主线程其他工作
.............
//等待异步方法完成，调用EndInvoke(IAsyncResult)获取运行结果
string data = myDelegate.EndInvoke(result);
Console.WriteLine(data);
Console.ReadKey();
}
static string Hello(string name) {
ThreadMessage("Async Thread");
Thread.Sleep(2000); //虚拟异步工作
return "Hello " + name;
}
//显示当前线程
static void ThreadMessage(string data) {
string message = string.Format("{0}\n ThreadId is:{1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}
运行结果
5.1.6. 4.6 善用 IAsyncResult
在以上例子中可以看见，如果在使用 myDelegate.BeginInvoke 后立即调用 myDelegate.EndInvoke，那在异步线程未完成工作以前主线程将处于阻塞状态，等到异步线程结束获取计算结果后，主线程才能继续工作，这明显无法展示出多线程的优势。此时可以好好利用 IAsyncResult 提高主线程的工作性能，IAsyncResult 有以下成员：
public interface IAsyncResult
{
object AsyncState { get; } //获取用户定义的对象，它限定或包含关于异步操作的信息。
WailHandle AsyncWaitHandle { get; } //获取用于等待异步操作完成的 WaitHandle。
bool CompletedSynchronously { get; } //获取异步操作是否同步完成的指示。
bool IsCompleted { get; } //获取异步操作是否已完成的指示。
}
通过轮询方式，使用 IsCompleted 属性判断异步操作是否完成，这样在异步操作未完成前就可以让主线程执行另外的工作。
class Program
{
delegate string MyDelegate(string name);
static void Main(string[] args)
{
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//异步调用委托，获取计算结果
IAsyncResult result = myDelegate.BeginInvoke("Leslie", null, null);
//在异步线程未完成前执行其他工作
while (!result.IsCompleted)
{
Thread.Sleep(200); //虚拟操作
Console.WriteLine("Main thead do work!");
}
string data = myDelegate.EndInvoke(result);
Console.WriteLine(data);
Console.ReadKey();
}
static string Hello(string name)
{
ThreadMessage("Async Thread");
Thread.Sleep(2000);
return "Hello " + name;
}
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n ThreadId is:{1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}
运行结果：
除此以外，也可以使用 WailHandle 完成同样的工作，WaitHandle 里面包含有一个方法 WaitOne(int timeout)，它可以判断委托是否完成工作，在工作未完成前主线程可以继续其他工作。运行下面代码可得到与使用 IAsyncResult.IsCompleted 同样的结果，而且更简单方便 。
namespace Test
{
class Program
{
delegate string MyDelegate(string name);
static void Main(string[] args)
{
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//异步调用委托，获取计算结果
IAsyncResult result = myDelegate.BeginInvoke("Leslie", null, null);
while (!result.AsyncWaitHandle.WaitOne(200))
{
Console.WriteLine("Main thead do work!");
}
string data = myDelegate.EndInvoke(result);
Console.WriteLine(data);
Console.ReadKey();
}
static string Hello(string name)
{
ThreadMessage("Async Thread");
Thread.Sleep(2000);
return "Hello " + name;
}
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n ThreadId is:{1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}
}
当要监视多个运行对象的时候，使用 IAsyncResult.WaitHandle.WaitOne 可就派不上用场了。
幸好.NET 为 WaitHandle 准备了另外两个静态方法：WaitAny(waitHandle[], int)与 WaitAll (waitHandle[] , int)。其中 WaitAll 在等待所有 waitHandle 完成后再返回一个 bool 值。而 WaitAny 是等待其中一个 waitHandle 完成后就返回一个 int，这个 int 是代表已完成 waitHandle 在 waitHandle[]中的数组索引。下面就是使用 WaitAll 的例子，运行结果与使用 IAsyncResult.IsCompleted 相同。
class Program
{
delegate string MyDelegate(string name);
static void Main(string[] args)
{
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//异步调用委托，获取计算结果
IAsyncResult result = myDelegate.BeginInvoke("Leslie", null, null);
//此处可加入多个检测对象
WaitHandle[] waitHandleList = new WaitHandle[] { result.AsyncWaitHandle,........ };
while (!WaitHandle.WaitAll(waitHandleList, 200))
{
Console.WriteLine("Main thead do work!");
}
string data = myDelegate.EndInvoke(result);
Console.WriteLine(data);
Console.ReadKey();
}
static string Hello(string name)
{
ThreadMessage("Async Thread");
Thread.Sleep(2000);
return "Hello " + name;
}
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n ThreadId is:{1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}
5.1.7. 4.7 回调函数
使用轮询方式来检测异步方法的状态非常麻烦，而且效率不高，有见及此，.NET 为 IAsyncResult BeginInvoke(AsyncCallback , object)准备了一个回调函数。使用 AsyncCallback 就可以绑定一个方法作为回调函数，回调函数必须是带参数 IAsyncResult 且无返回值的方法： void AsycnCallbackMethod(IAsyncResult result) 。在 BeginInvoke 方法完成后，系统就会调用 AsyncCallback 所绑定的回调函数,最后回调函数中调用 XXX EndInvoke(IAsyncResult result) 就可以结束异步方法，它的返回值类型与委托的返回值一致。
class Program
{
delegate string MyDelegate(string name);
static void Main(string[] args)
{
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//异步调用委托，获取计算结果
myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), null);
//在启动异步线程后，主线程可以继续工作而不需要等待
for (int n = 0; n < 6; n++)
Console.WriteLine(" Main thread do work!");
Console.WriteLine("");
Console.ReadKey();
}
static string Hello(string name)
{
ThreadMessage("Async Thread");
Thread.Sleep(2000); //模拟异步操作
return "\nHello " + name;
}
static void Completed(IAsyncResult result)
{
ThreadMessage("Async Completed");
//获取委托对象，调用EndInvoke方法获取运行结果
AsyncResult _result = (AsyncResult)result;
MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
string data = myDelegate.EndInvoke(_result);
Console.WriteLine(data);
}
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n ThreadId is:{1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}
可以看到，主线在调用 BeginInvoke 方法可以继续执行其他命令，而无需再等待了，这无疑比使用轮询方式判断异步方法是否完成更有优势。在异步方法执行完成后将会调用 AsyncCallback 所绑定的回调函数，注意一点，回调函数依然是在异步线程中执行，这样就不会影响主线程的运行，这也使用回调函数最值得青昧的地方。在回调函数中有一个既定的参数 IAsyncResult,把 IAsyncResult 强制转换为 AsyncResult 后，就可以通过 AsyncResult.AsyncDelegate 获取原委托，再使用 EndInvoke 方法获取计算结果。运行结果如下：
如果想为回调函数传送一些外部信息，就可以利用 BeginInvoke(AsyncCallback,object)的最后一个参数 object,它允许外部向回调函数输入任何类型的参数。只需要在回调函数中利用 AsyncResult.AsyncState 就可以获取 object 对象。
class Program
{
public class Person
{
public string Name;
public int Age;
}
delegate string MyDelegate(string name);
static void Main(string[] args)
{
ThreadMessage("Main Thread");
//建立委托
MyDelegate myDelegate = new MyDelegate(Hello);
//建立Person对象
Person person = new Person();
person.Name = "Elva";
person.Age = 27;
//异步调用委托，输入参数对象person, 获取计算结果
myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), person);
//在启动异步线程后，主线程可以继续工作而不需要等待
for (int n = 0; n < 6; n++)
Console.WriteLine(" Main thread do work!");
Console.WriteLine("");
Console.ReadKey();
}
static string Hello(string name)
{
ThreadMessage("Async Thread");
Thread.Sleep(2000);
return "\nHello " + name;
}
static void Completed(IAsyncResult result)
{
ThreadMessage("Async Completed");
//获取委托对象，调用EndInvoke方法获取运行结果
AsyncResult _result = (AsyncResult)result;
MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
string data = myDelegate.EndInvoke(_result);
//获取Person对象
Person person = (Person)result.AsyncState;
string message = person.Name + "'s age is " + person.Age.ToString();
Console.WriteLine(data + "\n" + message);
}
static void ThreadMessage(string data)
{
string message = string.Format("{0}\n ThreadId is:{1}",
data, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(message);
}
}
运行结果:
