文章內容

細說多線程(四）—— CLR線程池的工作者線程

發布時間: 2012/9/16 6:35:06

一、線程的定義

二、線程的基礎知識

三、以ThreadStart方式實現多線程

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

億恩-天使(QQ:530997) 電話 037160135991 服務器租用，托管歡迎咨詢。

本文出自：億恩科技【www.endtimedelusion.com】

服務器租用/服務器托管中國五強！虛擬主機域名注冊頂級提供商！15年品質保障！--億恩科技[ENKJ.COM]

上一篇 >> 細說多線程(四）—— CLR線程池的工作者線程
下一篇 >> 細說多線程（三）—— 以ThreadStart方式實現多線程

服務器租用

服務器托管

機柜批發

云服務器

建站俠

空間/域名

安全保姆

幫助類別

幫助中心

文章內容

細說多線程(四）—— CLR線程池的工作者線程

同類文章

億恩公告

在線客服