细说多线程(四）—— CLR线程池的工作者线程

目录

一、线程的定义

二、线程的基础知识

三、以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