目录

一、线程的定义

二、线程的基础知识

三、以ThreadStart方式实现多线程

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

五、CLR线程池的I/O线程

六、异步 SqlCommand

七、并行编程与PLINQ

八、计时器与锁

 

四、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 。

 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 }

运行结果

 

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

 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 }

运行结果

 

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

 

4.4  委托类       

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

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

 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 }

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

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 }

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

 

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

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

 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 }

运行结果

 

4.6  善用IAsyncResult

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

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

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

 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 }

运行结果:

 

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

 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 }

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

 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 }

 


4.7 回调函数

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

 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 }


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


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

 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 }

运行结果:

 对JAVA与.NET开发有兴趣的朋友欢迎加入QQ群:162338858 点击这里加入此群