C#綜合揭秘——細說多線程（上）

引言

本文主要從線程的基礎(chǔ)用法，CLR線程池當中工作者線程與I/O線程的開發(fā)，并行操作PLINQ等多個方面介紹多線程的開發(fā)。
其中委托的BeginInvoke方法以及回調(diào)函數(shù)最為常用。
而 I/O線程可能容易遭到大家的忽略，其實在開發(fā)多線程系統(tǒng)，更應(yīng)該多留意I/O線程的操作。特別是在ASP.NET開發(fā)當中，可能更多人只會留意在客戶端使用Ajax或者在服務(wù)器端使用UpdatePanel。其實合理使用I/O線程在通訊項目或文件下載時，能盡可能地減少IIS的壓力。
并行編程是Framework4.0中極力推廣的異步操作方式，更值得更深入地學(xué)習(xí)。
希望本篇文章能對各位的學(xué)習(xí)研究有所幫助，當中有所錯漏的地方敬請點評。?

目錄

一、線程的定義

二、線程的基礎(chǔ)知識

三、以ThreadStart方式實現(xiàn)多線程

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

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

六、異步 SqlCommand

七、并行編程與PLINQ

八、計時器與鎖??

?

一、線程的定義

?1. 1 進程、應(yīng)用程序域與線程的關(guān)系

進程（Process）是Windows系統(tǒng)中的一個基本概念，它包含著一個運行程序所需要的資源。進程之間是相對獨立的，一個進程無法訪問另一個進程的數(shù)據(jù)（除非利用分布式計算方式），一個進程運行的失敗也不會影響其他進程的運行，Windows系統(tǒng)就是利用進程把工作劃分為多個獨立的區(qū)域的。進程可以理解為一個程序的基本邊界。

應(yīng)用程序域（AppDomain）是一個程序運行的邏輯區(qū)域，它可以視為一個輕量級的進程，.NET的程序集正是在應(yīng)用程序域中運行的，一個進程可以包含有多個應(yīng)用程序域，一個應(yīng)用程序域也可以包含多個程序集。在一個應(yīng)用程序域中包含了一個或多個上下文context，使用上下文CLR就能夠把某些特殊對象的狀態(tài)放置在不同容器當中。

線程（Thread）是進程中的基本執(zhí)行單元，在進程入口執(zhí)行的第一個線程被視為這個進程的主線程。在.NET應(yīng)用程序中，都是以Main()方法作為入口的，當調(diào)用此方法時系統(tǒng)就會自動創(chuàng)建一個主線程。線程主要是由CPU寄存器、調(diào)用棧和線程本地存儲器（Thread Local Storage，TLS）組成的。CPU寄存器主要記錄當前所執(zhí)行線程的狀態(tài)，調(diào)用棧主要用于維護線程所調(diào)用到的內(nèi)存與數(shù)據(jù)，TLS主要用于存放線程的狀態(tài)信息。

進程、應(yīng)用程序域、線程的關(guān)系如下圖，一個進程內(nèi)可以包括多個應(yīng)用程序域，也有包括多個線程，線程也可以穿梭于多個應(yīng)用程序域當中。但在同一個時刻，線程只會處于一個應(yīng)用程序域內(nèi)。

?

?
由于本文是以介紹多線程技術(shù)為主題，對進程、應(yīng)用程序域的介紹就到此為止。關(guān)于進程、線程、應(yīng)用程序域的技術(shù)，在“C#綜合揭秘——細說進程、應(yīng)用程序域與上下文”會有詳細介紹。?

1.2 多線程

在單CPU系統(tǒng)的一個單位時間（time slice）內(nèi)，CPU只能運行單個線程，運行順序取決于線程的優(yōu)先級別。如果在單位時間內(nèi)線程未能完成執(zhí)行，系統(tǒng)就會把線程的狀態(tài)信息保存到線程的本地存儲器（TLS） 中，以便下次執(zhí)行時恢復(fù)執(zhí)行。而多線程只是系統(tǒng)帶來的一個假像，它在多個單位時間內(nèi)進行多個線程的切換。因為切換頻密而且單位時間非常短暫，所以多線程可被視作同時運行。

適當使用多線程能提高系統(tǒng)的性能，比如：在系統(tǒng)請求大容量的數(shù)據(jù)時使用多線程，把數(shù)據(jù)輸出工作交給異步線程，使主線程保持其穩(wěn)定性去處理其他問題。但需要注意一點，因為CPU需要花費不少的時間在線程的切換上，所以過多地使用多線程反而會導(dǎo)致性能的下降。?

返回目錄

二、線程的基礎(chǔ)知識

2.1 System.Threading.Thread類

System.Threading.Thread是用于控制線程的基礎(chǔ)類，通過Thread可以控制當前應(yīng)用程序域中線程的創(chuàng)建、掛起、停止、銷毀。

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

屬性名稱說明

CurrentContext	獲取線程正在其中執(zhí)行的當前上下文。
CurrentThread	獲取當前正在運行的線程。
ExecutionContext	獲取一個 ExecutionContext 對象，該對象包含有關(guān)當前線程的各種上下文的信息。
IsAlive	獲取一個值，該值指示當前線程的執(zhí)行狀態(tài)。
IsBackground	獲取或設(shè)置一個值，該值指示某個線程是否為后臺線程。
IsThreadPoolThread	獲取一個值，該值指示線程是否屬于托管線程池。
ManagedThreadId	獲取當前托管線程的唯一標識符。
Name	獲取或設(shè)置線程的名稱。
Priority	獲取或設(shè)置一個值，該值指示線程的調(diào)度優(yōu)先級。
ThreadState	獲取一個值，該值包含當前線程的狀態(tài)。

?2.1.1 線程的標識符

ManagedThreadId是確認線程的唯一標識符，程序在大部分情況下都是通過Thread.ManagedThreadId來辨別線程的。而Name是一個可變值，在默認時候，Name為一個空值 Null，開發(fā)人員可以通過程序設(shè)置線程的名稱，但這只是一個輔助功能。?

2.1.2 線程的優(yōu)先級別

.NET為線程設(shè)置了Priority屬性來定義線程執(zhí)行的優(yōu)先級別，里面包含5個選項，其中Normal是默認值。除非系統(tǒng)有特殊要求，否則不應(yīng)該隨便設(shè)置線程的優(yōu)先級別。

成員名稱說明

Lowest	可以將 Thread 安排在具有任何其他優(yōu)先級的線程之后。
BelowNormal	可以將 Thread 安排在具有 Normal 優(yōu)先級的線程之后，在具有 Lowest 優(yōu)先級的線程之前。
Normal	默認選擇。可以將 Thread 安排在具有 AboveNormal 優(yōu)先級的線程之后，在具有 BelowNormal 優(yōu)先級的線程之前。
AboveNormal	可以將 Thread 安排在具有 Highest 優(yōu)先級的線程之后，在具有 Normal 優(yōu)先級的線程之前。
Highest	可以將 Thread 安排在具有任何其他優(yōu)先級的線程之前。

2.1.3 線程的狀態(tài)

通過ThreadState可以檢測線程是處于Unstarted、Sleeping、Running 等等狀態(tài)，它比 IsAlive 屬性能提供更多的特定信息。

前面說過，一個應(yīng)用程序域中可能包括多個上下文，而通過CurrentContext可以獲取線程當前的上下文。

CurrentThread是最常用的一個屬性，它是用于獲取當前運行的線程。?

2.1.4 System.Threading.Thread的方法

Thread 中包括了多個方法來控制線程的創(chuàng)建、掛起、停止、銷毀，以后來的例子中會經(jīng)常使用。

方法名稱說明

Abort()	終止本線程。
GetDomain()	返回當前線程正在其中運行的當前域。
GetDomainId()	返回當前線程正在其中運行的當前域Id。
Interrupt()	中斷處于 WaitSleepJoin 線程狀態(tài)的線程。
Join()	已重載。 阻塞調(diào)用線程，直到某個線程終止時為止。
Resume()	繼續(xù)運行已掛起的線程。
Start()	執(zhí)行本線程。
Suspend()	掛起當前線程，如果當前線程已屬于掛起狀態(tài)則此不起作用
Sleep()	把正在運行的線程掛起一段時間。

?2.1.5 開發(fā)實例

以下這個例子，就是通過Thread顯示當前線程信息

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 }

?運行結(jié)果

?

2.2? System.Threading 命名空間

在System.Threading命名空間內(nèi)提供多個方法來構(gòu)建多線程應(yīng)用程序,其中ThreadPool與Thread是多線程開發(fā)中最常用到的，在.NET中專門設(shè)定了一個CLR線程池專門用于管理線程的運行，這個CLR線程池正是通過ThreadPool類來管理。而Thread是管理線程的最直接方式，下面幾節(jié)將詳細介紹有關(guān)內(nèi)容。

類	說明
AutoResetEvent	通知正在等待的線程已發(fā)生事件。無法繼承此類。
ExecutionContext	管理當前線程的執(zhí)行上下文。無法繼承此類。
Interlocked	為多個線程共享的變量提供原子操作。
Monitor	提供同步對對象的訪問的機制。
Mutex	一個同步基元，也可用于進程間同步。
Thread	創(chuàng)建并控制線程，設(shè)置其優(yōu)先級并獲取其狀態(tài)。
ThreadAbortException	在對 Abort 方法進行調(diào)用時引發(fā)的異常。無法繼承此類。
ThreadPool	提供一個線程池，該線程池可用于發(fā)送工作項、處理異步 I/O、代表其他線程等待以及處理計時器。
Timeout	包含用于指定無限長的時間的常數(shù)。無法繼承此類。
Timer	提供以指定的時間間隔執(zhí)行方法的機制。無法繼承此類。
WaitHandle	封裝等待對共享資源的獨占訪問的操作系統(tǒng)特定的對象。

在System.Threading中的包含了下表中的多個常用委托，其中ThreadStart、ParameterizedThreadStart是最常用到的委托。
由ThreadStart生成的線程是最直接的方式，但由ThreadStart所生成并不受線程池管理。
而ParameterizedThreadStart是為異步觸發(fā)帶參數(shù)的方法而設(shè)的，在下一節(jié)將為大家逐一細說。

委托說明

ContextCallback	表示要在新上下文中調(diào)用的方法。
ParameterizedThreadStart	表示在 Thread 上執(zhí)行的方法。
ThreadExceptionEventHandler	表示將要處理 Application 的 ThreadException 事件的方法。
ThreadStart	表示在 Thread 上執(zhí)行的方法。
TimerCallback	表示處理來自 Timer 的調(diào)用的方法。
WaitCallback	表示線程池線程要執(zhí)行的回調(diào)方法。
WaitOrTimerCallback	表示當 WaitHandle 超時或終止時要調(diào)用的方法。

?2.3 線程的管理方式

通過ThreadStart來創(chuàng)建一個新線程是最直接的方法，但這樣創(chuàng)建出來的線程比較難管理，如果創(chuàng)建過多的線程反而會讓系統(tǒng)的性能下載。有見及此，.NET為線程管理專門設(shè)置了一個CLR線程池，使用CLR線程池系統(tǒng)可以更合理地管理線程的使用。所有請求的服務(wù)都能運行于線程池中，當運行結(jié)束時線程便會回歸到線程池。通過設(shè)置，能控制線程池的最大線程數(shù)量，在請求超出線程最大值時，線程池能按照操作的優(yōu)先級別來執(zhí)行，讓部分操作處于等待狀態(tài)，待有線程回歸時再執(zhí)行操作。

基礎(chǔ)知識就為大家介紹到這里，下面將詳細介紹多線程的開發(fā)。?

返回目錄

三、以ThreadStart方式實現(xiàn)多線程

3.1 使用ThreadStart委托

這里先以一個例子體現(xiàn)一下多線程帶來的好處，首先在Message類中建立一個方法ShowMessage()，里面顯示了當前運行線程的Id，并使用Thread.Sleep（int ) 方法模擬部分工作。在main()中通過ThreadStart委托綁定Message對象的ShowMessage（）方法，然后通過Thread.Start（）執(zhí)行異步方法。

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 }

請注意運行結(jié)果，在調(diào)用Thread.Start()方法后，系統(tǒng)以異步方式運行Message.ShowMessage()，而主線程的操作是繼續(xù)執(zhí)行的，在Message.ShowMessage()完成前，主線程已完成所有的操作。

?3.2 使用ParameterizedThreadStart委托

ParameterizedThreadStart委托與ThreadStart委托非常相似，但ParameterizedThreadStart委托是面向帶參數(shù)方法的。注意ParameterizedThreadStart 對應(yīng)方法的參數(shù)為object，此參數(shù)可以為一個值對象，也可以為一個自定義對象。

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 //綁定帶參數(shù)的異步方法
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 }

運行結(jié)果：

3.3 前臺線程與后臺線程

注意以上兩個例子都沒有使用Console.ReadKey（）,但系統(tǒng)依然會等待異步線程完成后才會結(jié)束。這是因為使用Thread.Start()啟動的線程默認為前臺線程，而系統(tǒng)必須等待所有前臺線程運行結(jié)束后，應(yīng)用程序域才會自動卸載。

在第二節(jié)曾經(jīng)介紹過線程Thread有一個屬性IsBackground，通過把此屬性設(shè)置為true，就可以把線程設(shè)置為后臺線程！這時應(yīng)用程序域?qū)⒃谥骶€程完成時就被卸載，而不會等待異步線程的運行。

3.4 掛起線程

為了等待其他后臺線程完成后再結(jié)束主線程，就可以使用Thread.Sleep()方法。

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 }

運行結(jié)果如下，此時應(yīng)用程序域?qū)⒃谥骶€程運行5秒后自動結(jié)束

但系統(tǒng)無法預(yù)知異步線程需要運行的時間，所以用通過Thread.Sleep（int）阻塞主線程并不是一個好的解決方法。有見及此，.NET專門為等待異步線程完成開發(fā)了另一個方法thread.Join()。把上面例子中的最后一行Thread.Sleep（5000）修改為 thread.Join() 就能保證主線程在異步線程thread運行結(jié)束后才會終止。

3.5 Suspend 與 Resume （慎用）

Thread.Suspend（）與 Thread.Resume（）是在Framework1.0 就已經(jīng)存在的老方法了，它們分別可以掛起、恢復(fù)線程。但在Framework2.0中就已經(jīng)明確排斥這兩個方法。這是因為一旦某個線程占用了已有的資源，再使用Suspend（）使線程長期處于掛起狀態(tài)，當在其他線程調(diào)用這些資源的時候就會引起死鎖！所以在沒有必要的情況下應(yīng)該避免使用這兩個方法。

3.6 終止線程

若想終止正在運行的線程，可以使用Abort（）方法。在使用Abort（）的時候，將引發(fā)一個特殊異常 ThreadAbortException 。
若想在線程終止前恢復(fù)線程的執(zhí)行，可以在捕獲異常后 ,在catch（ThreadAbortException ex）{...} 中調(diào)用Thread.ResetAbort（）取消終止。
而使用Thread.Join（）可以保證應(yīng)用程序域等待異步線程結(jié)束后才終止運行。

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 //以異步方式調(diào)用
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 //取消終止，繼續(xù)執(zhí)行線程
41 Thread.ResetAbort();
42 Console.WriteLine("Thread ResetAbort!");
43 }
44
45 //線程結(jié)束
46 Console.WriteLine("Thread Close!");
47 }

運行結(jié)果如下

?

返回目錄

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

4.1 關(guān)于CLR線程池

使用ThreadStart與ParameterizedThreadStart建立新線程非常簡單，但通過此方法建立的線程難于管理，若建立過多的線程反而會影響系統(tǒng)的性能。
有見及此，.NET引入CLR線程池這個概念。CLR線程池并不會在CLR初始化的時候立刻建立線程，而是在應(yīng)用程序要創(chuàng)建線程來執(zhí)行任務(wù)時，線程池才初始化一個線程。線程的初始化與其他的線程一樣。在完成任務(wù)以后，該線程不會自行銷毀，而是以掛起的狀態(tài)返回到線程池。直到應(yīng)用程序再次向線程池發(fā)出請求時，線程池里掛起的線程就會再度激活執(zhí)行任務(wù)。這樣既節(jié)省了建立線程所造成的性能損耗，也可以讓多個任務(wù)反復(fù)重用同一線程，從而在應(yīng)用程序生存期內(nèi)節(jié)約大量開銷。

注意：通過CLR線程池所建立的線程總是默認為后臺線程，優(yōu)先級數(shù)為ThreadPriority.Normal。

4.2 工作者線程與I/O線程

CLR線程池分為工作者線程（workerThreads）與I/O線程 (completionPortThreads) 兩種，工作者線程是主要用作管理CLR內(nèi)部對象的運作，I/O（Input/Output) 線程顧名思義是用于與外部系統(tǒng)交換信息，IO線程的細節(jié)將在下一節(jié)詳細說明。

通過ThreadPool.GetMax（out int workerThreads,out int completionPortThreads )和 ThreadPool.SetMax( int workerThreads, int completionPortThreads)兩個方法可以分別讀取和設(shè)置CLR線程池中工作者線程與I/O線程的最大線程數(shù)。在Framework2.0中最大線程默認為25*CPU數(shù)，在Framewok3.0、4.0中最大線程數(shù)默認為250*CPU數(shù)，在近年 I3,I5,I7 CPU出現(xiàn)后，線程池的最大值一般默認為1000、2000。
若想測試線程池中有多少的線程正在投入使用，可以通過ThreadPool.GetAvailableThreads( out int workerThreads,out int completionPortThreads ) 方法。

使用CLR線程池的工作者線程一般有兩種方式，一是直接通過 ThreadPool.QueueUserWorkItem() 方法，二是通過委托，下面將逐一細說。?

4.3 通過QueueUserWorkItem啟動工作者線程

ThreadPool線程池中包含有兩個靜態(tài)方法可以直接啟動工作者線程：
一為 ThreadPool.QueueUserWorkItem(WaitCallback)
二為 ThreadPool.QueueUserWorkItem(WaitCallback,Object)?

先把WaitCallback委托指向一個帶有Object參數(shù)的無返回值方法，再使用 ThreadPool.QueueUserWorkItem(WaitCallback) 就可以異步啟動此方法，此時異步方法的參數(shù)被視為null 。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 //把CLR線程池的最大值設(shè)置為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 //顯示線程現(xiàn)狀
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 }

運行結(jié)果

?

使用 ThreadPool.QueueUserWorkItem(WaitCallback,Object) 方法可以把object對象作為參數(shù)傳送到回調(diào)函數(shù)中。
下面例子中就是把一個string對象作為參數(shù)發(fā)送到回調(diào)函數(shù)當中。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 //把線程池的最大值設(shè)置為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 //顯示線程現(xiàn)狀
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 }

運行結(jié)果

?

通過ThreadPool.QueueUserWorkItem啟動工作者線程雖然是方便，但WaitCallback委托指向的必須是一個帶有Object參數(shù)的無返回值方法，這無疑是一種限制。若方法需要有返回值，或者帶有多個參數(shù)，這將多費周折。有見及此，.NET提供了另一種方式去建立工作者線程，那就是委托。?

4.4? 委托類　　　　　　　

使用CLR線程池中的工作者線程，最靈活最常用的方式就是使用委托的異步方法，在此先簡單介紹一下委托類。

當定義委托后，.NET就會自動創(chuàng)建一個代表該委托的類，下面可以用反射方式顯示委托類的方法成員（對反射有興趣的朋友可以先參考一下“.NET基礎(chǔ)篇——反射的奧妙”）

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 //調(diào)用委托方法
5 public virtual void Invoke();
6 //異步委托
7 public virtual IAsyncResult BeginInvoke(AsyncCallback callback,object state);
8 public virtual void EndInvoke(IAsyncResult result);
9 }

當調(diào)用Invoke（）方法時，對應(yīng)此委托的所有方法都會被執(zhí)行。而BeginInvoke與EndInvoke則支持委托方法的異步調(diào)用，由BeginInvoke啟動的線程都屬于CLR線程池中的工作者線程，在下面將詳細說明。?

4.5? 利用BeginInvoke與EndInvoke完成異步委托方法

首先建立一個委托對象，通過IAsyncResult BeginInvoke(string name,AsyncCallback callback,object state) 異步調(diào)用委托方法，BeginInvoke 方法除最后的兩個參數(shù)外，其它參數(shù)都是與方法參數(shù)相對應(yīng)的。通過 BeginInvoke 方法將返回一個實現(xiàn)了 System.IAsyncResult 接口的對象，之后就可以利用EndInvoke（IAsyncResult ) 方法就可以結(jié)束異步操作，獲取委托的運行結(jié)果。

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 //異步調(diào)用委托，獲取計算結(jié)果
12 IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
13 //完成主線程其他工作
14 .............
15 //等待異步方法完成，調(diào)用EndInvoke(IAsyncResult)獲取運行結(jié)果
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 }

運行結(jié)果

?

4.6? 善用IAsyncResult

在以上例子中可以看見，如果在使用myDelegate.BeginInvoke后立即調(diào)用myDelegate.EndInvoke，那在異步線程未完成工作以前主線程將處于阻塞狀態(tài)，等到異步線程結(jié)束獲取計算結(jié)果后，主線程才能繼續(xù)工作，這明顯無法展示出多線程的優(yōu)勢。此時可以好好利用IAsyncResult 提高主線程的工作性能，IAsyncResult有以下成員：

1 public interface IAsyncResult
2 {
3 object AsyncState {get;} //獲取用戶定義的對象，它限定或包含關(guān)于異步操作的信息。
4 WailHandle AsyncWaitHandle {get;} //獲取用于等待異步操作完成的 WaitHandle。
5 bool CompletedSynchronously {get;} //獲取異步操作是否同步完成的指示。
6 bool IsCompleted {get;} //獲取異步操作是否已完成的指示。
7 }

通過輪詢方式，使用IsCompleted屬性判斷異步操作是否完成，這樣在異步操作未完成前就可以讓主線程執(zhí)行另外的工作。

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 //異步調(diào)用委托，獲取計算結(jié)果
12 IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
13 //在異步線程未完成前執(zhí)行其他工作
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 }

運行結(jié)果：

除此以外，也可以使用WailHandle完成同樣的工作，WaitHandle里面包含有一個方法WaitOne（int timeout），它可以判斷委托是否完成工作，在工作未完成前主線程可以繼續(xù)其他工作。運行下面代碼可得到與使用 IAsyncResult.IsCompleted 同樣的結(jié)果，而且更簡單方便 。

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 //異步調(diào)用委托，獲取計算結(jié)果
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 }

當要監(jiān)視多個運行對象的時候，使用IAsyncResult.WaitHandle.WaitOne可就派不上用場了。
幸好.NET為WaitHandle準備了另外兩個靜態(tài)方法：WaitAny（waitHandle[], int）與WaitAll (waitHandle[] , int)。
其中WaitAll在等待所有waitHandle完成后再返回一個bool值。
而WaitAny是等待其中一個waitHandle完成后就返回一個int，這個int是代表已完成waitHandle在waitHandle[]中的數(shù)組索引。
下面就是使用WaitAll的例子，運行結(jié)果與使用 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 //異步調(diào)用委托，獲取計算結(jié)果
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 回調(diào)函數(shù)

使用輪詢方式來檢測異步方法的狀態(tài)非常麻煩，而且效率不高，有見及此，.NET為 IAsyncResult BeginInvoke（AsyncCallback , object）準備了一個回調(diào)函數(shù)。使用 AsyncCallback 就可以綁定一個方法作為回調(diào)函數(shù)，回調(diào)函數(shù)必須是帶參數(shù) IAsyncResult 且無返回值的方法： void AsycnCallbackMethod(IAsyncResult result) 。在BeginInvoke方法完成后，系統(tǒng)就會調(diào)用AsyncCallback所綁定的回調(diào)函數(shù),最后回調(diào)函數(shù)中調(diào)用 XXX EndInvoke（IAsyncResult result) 就可以結(jié)束異步方法，它的返回值類型與委托的返回值一致。

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 //異步調(diào)用委托，獲取計算結(jié)果
12 myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), null);
13 //在啟動異步線程后，主線程可以繼續(xù)工作而不需要等待
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 //獲取委托對象，調(diào)用EndInvoke方法獲取運行結(jié)果
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 }

可以看到，主線在調(diào)用BeginInvoke方法可以繼續(xù)執(zhí)行其他命令，而無需再等待了，這無疑比使用輪詢方式判斷異步方法是否完成更有優(yōu)勢。
在異步方法執(zhí)行完成后將會調(diào)用AsyncCallback所綁定的回調(diào)函數(shù)，注意一點，回調(diào)函數(shù)依然是在異步線程中執(zhí)行，這樣就不會影響主線程的運行，這也使用回調(diào)函數(shù)最值得青昧的地方。
在回調(diào)函數(shù)中有一個既定的參數(shù)IAsyncResult,把IAsyncResult強制轉(zhuǎn)換為AsyncResult后，就可以通過 AsyncResult.AsyncDelegate 獲取原委托，再使用EndInvoke方法獲取計算結(jié)果。
運行結(jié)果如下：

如果想為回調(diào)函數(shù)傳送一些外部信息，就可以利用BeginInvoke(AsyncCallback,object)的最后一個參數(shù)object,它允許外部向回調(diào)函數(shù)輸入任何類型的參數(shù)。只需要在回調(diào)函數(shù)中利用 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 //異步調(diào)用委托，輸入?yún)?shù)對象person, 獲取計算結(jié)果
24 myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), person);
25
26 //在啟動異步線程后，主線程可以繼續(xù)工作而不需要等待
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 //獲取委托對象，調(diào)用EndInvoke方法獲取運行結(jié)果
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 }

運行結(jié)果:

關(guān)于I/O線程、SqlCommand多線程查詢、PLINQ、定時器與鎖的內(nèi)容將在C#綜合揭秘——細說多線程（下）中詳細介紹。

轉(zhuǎn)載于:https://www.cnblogs.com/go-jzg/p/6274229.html

總結(jié)

以上是生活随笔為你收集整理的[转]C#综合揭秘——细说多线程（上）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。