C#综合揭秘——细说多线程（上）
引言
本文主要從線程的基礎(chǔ)用法，CLR線程池當(dāng)中工作者線程與I/O線程的開(kāi)發(fā)，并行操作PLINQ等多個(gè)方面介紹多線程的開(kāi)發(fā)。
其中委托的BeginInvoke方法以及回調(diào)函數(shù)最為常用。
而 I/O線程可能容易遭到大家的忽略，其實(shí)在開(kāi)發(fā)多線程系統(tǒng)，更應(yīng)該多留意I/O線程的操作。特別是在ASP.NET開(kāi)發(fā)當(dāng)中，可能更多人只會(huì)留意在客戶端使用Ajax或者在服務(wù)器端使用UpdatePanel。其實(shí)合理使用I/O線程在通訊項(xiàng)目或文件下載時(shí)，能盡可能地減少I(mǎi)IS的壓力。
并行編程是Framework4.0中極力推廣的異步操作方式，更值得更深入地學(xué)習(xí)。
希望本篇文章能對(duì)各位的學(xué)習(xí)研究有所幫助，當(dāng)中有所錯(cuò)漏的地方敬請(qǐng)點(diǎn)評(píng)。
?
?
目錄
一、線程的定義
二、線程的基礎(chǔ)知識(shí)
三、以ThreadStart方式實(shí)現(xiàn)多線程
四、CLR線程池的工作者線程
五、CLR線程池的I/O線程
六、異步 SqlCommand
七、并行編程與PLINQ
八、計(jì)時(shí)器與鎖
?
?
?
?
一、線程的定義
?1. 1 進(jìn)程、應(yīng)用程序域與線程的關(guān)系
進(jìn)程（Process）是Windows系統(tǒng)中的一個(gè)基本概念，它包含著一個(gè)運(yùn)行程序所需要的資源。進(jìn)程之間是相對(duì)獨(dú)立的，一個(gè)進(jìn)程無(wú)法訪問(wèn)另一個(gè)進(jìn)程的數(shù)據(jù)（除非利用分布式計(jì)算方式），一個(gè)進(jìn)程運(yùn)行的失敗也不會(huì)影響其他進(jìn)程的運(yùn)行，Windows系統(tǒng)就是利用進(jìn)程把工作劃分為多個(gè)獨(dú)立的區(qū)域的。進(jìn)程可以理解為一個(gè)程序的基本邊界。
應(yīng)用程序域（AppDomain）是一個(gè)程序運(yùn)行的邏輯區(qū)域，它可以視為一個(gè)輕量級(jí)的進(jìn)程，.NET的程序集正是在應(yīng)用程序域中運(yùn)行的，一個(gè)進(jìn)程可以包含有多個(gè)應(yīng)用程序域，一個(gè)應(yīng)用程序域也可以包含多個(gè)程序集。在一個(gè)應(yīng)用程序域中包含了一個(gè)或多個(gè)上下文context，使用上下文CLR就能夠把某些特殊對(duì)象的狀態(tài)放置在不同容器當(dāng)中。
線程（Thread）是進(jìn)程中的基本執(zhí)行單元，在進(jìn)程入口執(zhí)行的第一個(gè)線程被視為這個(gè)進(jìn)程的主線程。在.NET應(yīng)用程序中，都是以Main()方法作為入口的，當(dāng)調(diào)用此方法時(shí)系統(tǒng)就會(huì)自動(dòng)創(chuàng)建一個(gè)主線程。線程主要是由CPU寄存器、調(diào)用棧和線程本地存儲(chǔ)器（Thread Local Storage，TLS）組成的。CPU寄存器主要記錄當(dāng)前所執(zhí)行線程的狀態(tài)，調(diào)用棧主要用于維護(hù)線程所調(diào)用到的內(nèi)存與數(shù)據(jù)，TLS主要用于存放線程的狀態(tài)信息。
進(jìn)程、應(yīng)用程序域、線程的關(guān)系如下圖，一個(gè)進(jìn)程內(nèi)可以包括多個(gè)應(yīng)用程序域，也有包括多個(gè)線程，線程也可以穿梭于多個(gè)應(yīng)用程序域當(dāng)中。但在同一個(gè)時(shí)刻，線程只會(huì)處于一個(gè)應(yīng)用程序域內(nèi)。
?
?
由于本文是以介紹多線程技術(shù)為主題，對(duì)進(jìn)程、應(yīng)用程序域的介紹就到此為止。關(guān)于進(jìn)程、線程、應(yīng)用程序域的技術(shù)，在“C#綜合揭秘——細(xì)說(shuō)進(jìn)程、應(yīng)用程序域與上下文”會(huì)有詳細(xì)介紹。
?
1.2 多線程
在單CPU系統(tǒng)的一個(gè)單位時(shí)間（time slice）內(nèi)，CPU只能運(yùn)行單個(gè)線程，運(yùn)行順序取決于線程的優(yōu)先級(jí)別。如果在單位時(shí)間內(nèi)線程未能完成執(zhí)行，系統(tǒng)就會(huì)把線程的狀態(tài)信息保存到線程的本地存儲(chǔ)器（TLS） 中，以便下次執(zhí)行時(shí)恢復(fù)執(zhí)行。而多線程只是系統(tǒng)帶來(lái)的一個(gè)假像，它在多個(gè)單位時(shí)間內(nèi)進(jìn)行多個(gè)線程的切換。因?yàn)榍袚Q頻密而且單位時(shí)間非常短暫，所以多線程可被視作同時(shí)運(yùn)行。
適當(dāng)使用多線程能提高系統(tǒng)的性能，比如：在系統(tǒng)請(qǐng)求大容量的數(shù)據(jù)時(shí)使用多線程，把數(shù)據(jù)輸出工作交給異步線程，使主線程保持其穩(wěn)定性去處理其他問(wèn)題。但需要注意一點(diǎn)，因?yàn)镃PU需要花費(fèi)不少的時(shí)間在線程的切換上，所以過(guò)多地使用多線程反而會(huì)導(dǎo)致性能的下降。
?
返回目錄
二、線程的基礎(chǔ)知識(shí)
2.1 System.Threading.Thread類
System.Threading.Thread是用于控制線程的基礎(chǔ)類，通過(guò)Thread可以控制當(dāng)前應(yīng)用程序域中線程的創(chuàng)建、掛起、停止、銷(xiāo)毀。
它包括以下常用公共屬性：
| CurrentContext | 獲取線程正在其中執(zhí)行的當(dāng)前上下文。 |
| CurrentThread | 獲取當(dāng)前正在運(yùn)行的線程。 |
| ExecutionContext | 獲取一個(gè) ExecutionContext 對(duì)象，該對(duì)象包含有關(guān)當(dāng)前線程的各種上下文的信息。 |
| IsAlive | 獲取一個(gè)值，該值指示當(dāng)前線程的執(zhí)行狀態(tài)。 |
| IsBackground | 獲取或設(shè)置一個(gè)值，該值指示某個(gè)線程是否為后臺(tái)線程。 |
| IsThreadPoolThread | 獲取一個(gè)值，該值指示線程是否屬于托管線程池。 |
| ManagedThreadId | 獲取當(dāng)前托管線程的唯一標(biāo)識(shí)符。 |
| Name | 獲取或設(shè)置線程的名稱。 |
| Priority | 獲取或設(shè)置一個(gè)值，該值指示線程的調(diào)度優(yōu)先級(jí)。 |
| ThreadState | 獲取一個(gè)值，該值包含當(dāng)前線程的狀態(tài)。 |
?
2.1.1 線程的標(biāo)識(shí)符
ManagedThreadId是確認(rèn)線程的唯一標(biāo)識(shí)符，程序在大部分情況下都是通過(guò)Thread.ManagedThreadId來(lái)辨別線程的。而Name是一個(gè)可變值，在默認(rèn)時(shí)候，Name為一個(gè)空值 Null，開(kāi)發(fā)人員可以通過(guò)程序設(shè)置線程的名稱，但這只是一個(gè)輔助功能。
?
2.1.2 線程的優(yōu)先級(jí)別
.NET為線程設(shè)置了Priority屬性來(lái)定義線程執(zhí)行的優(yōu)先級(jí)別，里面包含5個(gè)選項(xiàng)，其中Normal是默認(rèn)值。除非系統(tǒng)有特殊要求，否則不應(yīng)該隨便設(shè)置線程的優(yōu)先級(jí)別。
| Lowest | 可以將 Thread 安排在具有任何其他優(yōu)先級(jí)的線程之后。 |
| BelowNormal | 可以將 Thread 安排在具有?Normal?優(yōu)先級(jí)的線程之后，在具有?Lowest?優(yōu)先級(jí)的線程之前。 |
| Normal | 默認(rèn)選擇。可以將 Thread 安排在具有?AboveNormal?優(yōu)先級(jí)的線程之后，在具有BelowNormal?優(yōu)先級(jí)的線程之前。 |
| AboveNormal | 可以將 Thread 安排在具有?Highest?優(yōu)先級(jí)的線程之后，在具有?Normal?優(yōu)先級(jí)的線程之前。 |
| Highest | 可以將 Thread 安排在具有任何其他優(yōu)先級(jí)的線程之前。 |
?
2.1.3 線程的狀態(tài)
通過(guò)ThreadState可以檢測(cè)線程是處于Unstarted、Sleeping、Running 等等狀態(tài)，它比 IsAlive 屬性能提供更多的特定信息。
前面說(shuō)過(guò)，一個(gè)應(yīng)用程序域中可能包括多個(gè)上下文，而通過(guò)CurrentContext可以獲取線程當(dāng)前的上下文。
CurrentThread是最常用的一個(gè)屬性，它是用于獲取當(dāng)前運(yùn)行的線程。
?
2.1.4 System.Threading.Thread的方法
Thread 中包括了多個(gè)方法來(lái)控制線程的創(chuàng)建、掛起、停止、銷(xiāo)毀，以后來(lái)的例子中會(huì)經(jīng)常使用。
| Abort() | 終止本線程。 |
| GetDomain() | 返回當(dāng)前線程正在其中運(yùn)行的當(dāng)前域。 |
| GetDomainId() | 返回當(dāng)前線程正在其中運(yùn)行的當(dāng)前域Id。 |
| Interrupt() | 中斷處于 WaitSleepJoin 線程狀態(tài)的線程。 |
| Join() | 已重載。 阻塞調(diào)用線程，直到某個(gè)線程終止時(shí)為止。 |
| Resume() | 繼續(xù)運(yùn)行已掛起的線程。 |
| Start() | 執(zhí)行本線程。 |
| Suspend() | 掛起當(dāng)前線程，如果當(dāng)前線程已屬于掛起狀態(tài)則此不起作用 |
| Sleep() | 把正在運(yùn)行的線程掛起一段時(shí)間。 |
?
2.1.5 開(kāi)發(fā)實(shí)例
以下這個(gè)例子，就是通過(guò)Thread顯示當(dāng)前線程信息
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 }
?
運(yùn)行結(jié)果
?
2.2? System.Threading 命名空間
在System.Threading命名空間內(nèi)提供多個(gè)方法來(lái)構(gòu)建多線程應(yīng)用程序,其中ThreadPool與Thread是多線程開(kāi)發(fā)中最常用到的，在.NET中專門(mén)設(shè)定了一個(gè)CLR線程池專門(mén)用于管理線程的運(yùn)行，這個(gè)CLR線程池正是通過(guò)ThreadPool類來(lái)管理。而Thread是管理線程的最直接方式，下面幾節(jié)將詳細(xì)介紹有關(guān)內(nèi)容。
| 類 | 說(shuō)明 |
| AutoResetEvent | 通知正在等待的線程已發(fā)生事件。無(wú)法繼承此類。 |
| ExecutionContext | 管理當(dāng)前線程的執(zhí)行上下文。無(wú)法繼承此類。 |
| Interlocked | 為多個(gè)線程共享的變量提供原子操作。 |
| Monitor | 提供同步對(duì)對(duì)象的訪問(wèn)的機(jī)制。 |
| Mutex | 一個(gè)同步基元，也可用于進(jìn)程間同步。 |
| Thread | 創(chuàng)建并控制線程，設(shè)置其優(yōu)先級(jí)并獲取其狀態(tài)。 |
| ThreadAbortException | 在對(duì) Abort 方法進(jìn)行調(diào)用時(shí)引發(fā)的異常。無(wú)法繼承此類。 |
| ThreadPool | 提供一個(gè)線程池，該線程池可用于發(fā)送工作項(xiàng)、處理異步 I/O、代表其他線程等待以及處理計(jì)時(shí)器。 |
| Timeout | 包含用于指定無(wú)限長(zhǎng)的時(shí)間的常數(shù)。無(wú)法繼承此類。 |
| Timer | 提供以指定的時(shí)間間隔執(zhí)行方法的機(jī)制。無(wú)法繼承此類。 |
| WaitHandle | 封裝等待對(duì)共享資源的獨(dú)占訪問(wèn)的操作系統(tǒng)特定的對(duì)象。 |
在System.Threading中的包含了下表中的多個(gè)常用委托，其中ThreadStart、ParameterizedThreadStart是最常用到的委托。
由ThreadStart生成的線程是最直接的方式，但由ThreadStart所生成并不受線程池管理。
而ParameterizedThreadStart是為異步觸發(fā)帶參數(shù)的方法而設(shè)的，在下一節(jié)將為大家逐一細(xì)說(shuō)。
| ContextCallback | 表示要在新上下文中調(diào)用的方法。 |
| ParameterizedThreadStart | 表示在 Thread 上執(zhí)行的方法。 |
| ThreadExceptionEventHandler | 表示將要處理 Application 的 ThreadException 事件的方法。 |
| ThreadStart | 表示在 Thread 上執(zhí)行的方法。 |
| TimerCallback | 表示處理來(lái)自 Timer 的調(diào)用的方法。 |
| WaitCallback | 表示線程池線程要執(zhí)行的回調(diào)方法。 |
| WaitOrTimerCallback | 表示當(dāng) WaitHandle 超時(shí)或終止時(shí)要調(diào)用的方法。 |
?
2.3 線程的管理方式
通過(guò)ThreadStart來(lái)創(chuàng)建一個(gè)新線程是最直接的方法，但這樣創(chuàng)建出來(lái)的線程比較難管理，如果創(chuàng)建過(guò)多的線程反而會(huì)讓系統(tǒng)的性能下載。有見(jiàn)及此，.NET為線程管理專門(mén)設(shè)置了一個(gè)CLR線程池，使用CLR線程池系統(tǒng)可以更合理地管理線程的使用。所有請(qǐng)求的服務(wù)都能運(yùn)行于線程池中，當(dāng)運(yùn)行結(jié)束時(shí)線程便會(huì)回歸到線程池。通過(guò)設(shè)置，能控制線程池的最大線程數(shù)量，在請(qǐng)求超出線程最大值時(shí)，線程池能按照操作的優(yōu)先級(jí)別來(lái)執(zhí)行，讓部分操作處于等待狀態(tài)，待有線程回歸時(shí)再執(zhí)行操作。
基礎(chǔ)知識(shí)就為大家介紹到這里，下面將詳細(xì)介紹多線程的開(kāi)發(fā)。
?
?
返回目錄
三、以ThreadStart方式實(shí)現(xiàn)多線程
3.1 使用ThreadStart委托
這里先以一個(gè)例子體現(xiàn)一下多線程帶來(lái)的好處，首先在Message類中建立一個(gè)方法ShowMessage()，里面顯示了當(dāng)前運(yùn)行線程的Id，并使用Thread.Sleep（int ) 方法模擬部分工作。在main()中通過(guò)ThreadStart委托綁定Message對(duì)象的ShowMessage（）方法，然后通過(guò)Thread.Start（）執(zhí)行異步方法。
1 public class Message2 {
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 }
請(qǐng)注意運(yùn)行結(jié)果，在調(diào)用Thread.Start()方法后，系統(tǒng)以異步方式運(yùn)行Message.ShowMessage()，而主線程的操作是繼續(xù)執(zhí)行的，在Message.ShowMessage()完成前，主線程已完成所有的操作。
?
3.2 使用ParameterizedThreadStart委托
ParameterizedThreadStart委托與ThreadStart委托非常相似，但ParameterizedThreadStart委托是面向帶參數(shù)方法的。注意ParameterizedThreadStart 對(duì)應(yīng)方法的參數(shù)為object，此參數(shù)可以為一個(gè)值對(duì)象，也可以為一個(gè)自定義對(duì)象。
1 public class Person2 {
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); //啟動(dòng)異步線程
47
48 Console.WriteLine("Do something ..........!");
49 Console.WriteLine("Main thread working is complete!");
50
51 }
52 }
運(yùn)行結(jié)果：
?
3.3 前臺(tái)線程與后臺(tái)線程
注意以上兩個(gè)例子都沒(méi)有使用Console.ReadKey（）,但系統(tǒng)依然會(huì)等待異步線程完成后才會(huì)結(jié)束。這是因?yàn)槭褂肨hread.Start()啟動(dòng)的線程默認(rèn)為前臺(tái)線程，而系統(tǒng)必須等待所有前臺(tái)線程運(yùn)行結(jié)束后，應(yīng)用程序域才會(huì)自動(dòng)卸載。
在第二節(jié)曾經(jīng)介紹過(guò)線程Thread有一個(gè)屬性IsBackground，通過(guò)把此屬性設(shè)置為true，就可以把線程設(shè)置為后臺(tái)線程！這時(shí)應(yīng)用程序域?qū)⒃谥骶€程完成時(shí)就被卸載，而不會(huì)等待異步線程的運(yùn)行。
?
3.4 掛起線程
為了等待其他后臺(tái)線程完成后再結(jié)束主線程，就可以使用Thread.Sleep()方法。
1 public class Message2 {
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 }
運(yùn)行結(jié)果如下，此時(shí)應(yīng)用程序域?qū)⒃谥骶€程運(yùn)行5秒后自動(dòng)結(jié)束
?
但系統(tǒng)無(wú)法預(yù)知異步線程需要運(yùn)行的時(shí)間，所以用通過(guò)Thread.Sleep（int）阻塞主線程并不是一個(gè)好的解決方法。有見(jiàn)及此，.NET專門(mén)為等待異步線程完成開(kāi)發(fā)了另一個(gè)方法thread.Join()。把上面例子中的最后一行Thread.Sleep（5000）修改為 thread.Join() 就能保證主線程在異步線程thread運(yùn)行結(jié)束后才會(huì)終止。
?
3.5 Suspend 與 Resume （慎用）
Thread.Suspend（）與 Thread.Resume（）是在Framework1.0 就已經(jīng)存在的老方法了，它們分別可以掛起、恢復(fù)線程。但在Framework2.0中就已經(jīng)明確排斥這兩個(gè)方法。這是因?yàn)橐坏┠硞€(gè)線程占用了已有的資源，再使用Suspend（）使線程長(zhǎng)期處于掛起狀態(tài)，當(dāng)在其他線程調(diào)用這些資源的時(shí)候就會(huì)引起死鎖！所以在沒(méi)有必要的情況下應(yīng)該避免使用這兩個(gè)方法。
?
3.6 終止線程
若想終止正在運(yùn)行的線程，可以使用Abort（）方法。在使用Abort（）的時(shí)候，將引發(fā)一個(gè)特殊異常 ThreadAbortException 。
若想在線程終止前恢復(fù)線程的執(zhí)行，可以在捕獲異常后 ,在catch（ThreadAbortException ex）{...} 中調(diào)用Thread.ResetAbort（）取消終止。
而使用Thread.Join（）可以保證應(yīng)用程序域等待異步線程結(jié)束后才終止運(yùn)行。
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 //當(dāng)n等于4時(shí)，終止線程
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 //輸出終止線程時(shí)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 }
運(yùn)行結(jié)果如下
?
?
返回目錄
四、CLR線程池的工作者線程
4.1 關(guān)于CLR線程池
使用ThreadStart與ParameterizedThreadStart建立新線程非常簡(jiǎn)單，但通過(guò)此方法建立的線程難于管理，若建立過(guò)多的線程反而會(huì)影響系統(tǒng)的性能。
有見(jiàn)及此，.NET引入CLR線程池這個(gè)概念。CLR線程池并不會(huì)在CLR初始化的時(shí)候立刻建立線程，而是在應(yīng)用程序要?jiǎng)?chuàng)建線程來(lái)執(zhí)行任務(wù)時(shí)，線程池才初始化一個(gè)線程。線程的初始化與其他的線程一樣。在完成任務(wù)以后，該線程不會(huì)自行銷(xiāo)毀，而是以掛起的狀態(tài)返回到線程池。直到應(yīng)用程序再次向線程池發(fā)出請(qǐng)求時(shí)，線程池里掛起的線程就會(huì)再度激活執(zhí)行任務(wù)。這樣既節(jié)省了建立線程所造成的性能損耗，也可以讓多個(gè)任務(wù)反復(fù)重用同一線程，從而在應(yīng)用程序生存期內(nèi)節(jié)約大量開(kāi)銷(xiāo)。
注意：通過(guò)CLR線程池所建立的線程總是默認(rèn)為后臺(tái)線程，優(yōu)先級(jí)數(shù)為T(mén)hreadPriority.Normal。
?
4.2 工作者線程與I/O線程
CLR線程池分為工作者線程（workerThreads）與I/O線程 (completionPortThreads) 兩種，工作者線程是主要用作管理CLR內(nèi)部對(duì)象的運(yùn)作，I/O（Input/Output) 線程顧名思義是用于與外部系統(tǒng)交換信息，IO線程的細(xì)節(jié)將在下一節(jié)詳細(xì)說(shuō)明。
通過(guò)ThreadPool.GetMax（out int workerThreads,out int completionPortThreads )和 ThreadPool.SetMax( int workerThreads, int completionPortThreads)兩個(gè)方法可以分別讀取和設(shè)置CLR線程池中工作者線程與I/O線程的最大線程數(shù)。在Framework2.0中最大線程默認(rèn)為25*CPU數(shù)，在Framewok3.0、4.0中最大線程數(shù)默認(rèn)為250*CPU數(shù)，在近年 I3,I5,I7 CPU出現(xiàn)后，線程池的最大值一般默認(rèn)為1000、2000。
若想測(cè)試線程池中有多少的線程正在投入使用，可以通過(guò)ThreadPool.GetAvailableThreads(?out int?workerThreads,out int completionPortThreads ) 方法。
使用CLR線程池的工作者線程一般有兩種方式，一是直接通過(guò) ThreadPool.QueueUserWorkItem() 方法，二是通過(guò)委托，下面將逐一細(xì)說(shuō)。
?
4.3 通過(guò)QueueUserWorkItem啟動(dòng)工作者線程
ThreadPool線程池中包含有兩個(gè)靜態(tài)方法可以直接啟動(dòng)工作者線程：
一為 ThreadPool.QueueUserWorkItem(WaitCallback)
二為 ThreadPool.QueueUserWorkItem(WaitCallback,Object)?
先把WaitCallback委托指向一個(gè)帶有Object參數(shù)的無(wú)返回值方法，再使用 ThreadPool.QueueUserWorkItem(WaitCallback) 就可以異步啟動(dòng)此方法，此時(shí)異步方法的參數(shù)被視為null 。
1 class Program2 {
3 static void Main(string[] args)
4 {
5 //把CLR線程池的最大值設(shè)置為1000
6 ThreadPool.SetMaxThreads(1000, 1000);
7 //顯示主線程啟動(dòng)時(shí)線程池信息
8 ThreadMessage("Start");
9 //啟動(dòng)工作者線程
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 }
運(yùn)行結(jié)果
?
使用 ThreadPool.QueueUserWorkItem(WaitCallback,Object) 方法可以把object對(duì)象作為參數(shù)傳送到回調(diào)函數(shù)中。
下面例子中就是把一個(gè)string對(duì)象作為參數(shù)發(fā)送到回調(diào)函數(shù)當(dāng)中。
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 }
運(yùn)行結(jié)果
?
通過(guò)ThreadPool.QueueUserWorkItem啟動(dòng)工作者線程雖然是方便，但WaitCallback委托指向的必須是一個(gè)帶有Object參數(shù)的無(wú)返回值方法，這無(wú)疑是一種限制。若方法需要有返回值，或者帶有多個(gè)參數(shù)，這將多費(fèi)周折。有見(jiàn)及此，.NET提供了另一種方式去建立工作者線程，那就是委托。
?
4.4? 委托類
使用CLR線程池中的工作者線程，最靈活最常用的方式就是使用委托的異步方法，在此先簡(jiǎn)單介紹一下委托類。
當(dāng)定義委托后，.NET就會(huì)自動(dòng)創(chuàng)建一個(gè)代表該委托的類，下面可以用反射方式顯示委托類的方法成員（對(duì)反射有興趣的朋友可以先參考一下“.NET基礎(chǔ)篇——反射的奧妙”）
1 class Program2 {
3 delegate void MyDelegate();
4
5 static void Main(string[] args)
6 {
7 MyDelegate delegate1 = new MyDelegate(AsyncThread);
8 //顯示委托類的幾個(gè)方法成員
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 }
委托類包括以下幾個(gè)重要方法
1 public class MyDelegate:MulticastDelegate2 {
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 }
當(dāng)調(diào)用Invoke（）方法時(shí)，對(duì)應(yīng)此委托的所有方法都會(huì)被執(zhí)行。而B(niǎo)eginInvoke與EndInvoke則支持委托方法的異步調(diào)用，由BeginInvoke啟動(dòng)的線程都屬于CLR線程池中的工作者線程，在下面將詳細(xì)說(shuō)明。
?
4.5? 利用BeginInvoke與EndInvoke完成異步委托方法
首先建立一個(gè)委托對(duì)象，通過(guò)IAsyncResult BeginInvoke(string name,AsyncCallback callback,object state) 異步調(diào)用委托方法，BeginInvoke 方法除最后的兩個(gè)參數(shù)外，其它參數(shù)都是與方法參數(shù)相對(duì)應(yīng)的。通過(guò) BeginInvoke 方法將返回一個(gè)實(shí)現(xiàn)了 System.IAsyncResult 接口的對(duì)象，之后就可以利用EndInvoke（IAsyncResult ) 方法就可以結(jié)束異步操作，獲取委托的運(yùn)行結(jié)果。
1 class Program2 {
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)用委托，獲取計(jì)算結(jié)果
12 IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
13 //完成主線程其他工作
14 .............
15 //等待異步方法完成，調(diào)用EndInvoke(IAsyncResult)獲取運(yùn)行結(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 //顯示當(dāng)前線程
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 }
運(yùn)行結(jié)果
?
4.6? 善用IAsyncResult
在以上例子中可以看見(jiàn)，如果在使用myDelegate.BeginInvoke后立即調(diào)用myDelegate.EndInvoke，那在異步線程未完成工作以前主線程將處于阻塞狀態(tài)，等到異步線程結(jié)束獲取計(jì)算結(jié)果后，主線程才能繼續(xù)工作，這明顯無(wú)法展示出多線程的優(yōu)勢(shì)。此時(shí)可以好好利用IAsyncResult 提高主線程的工作性能，IAsyncResult有以下成員：
1 public interface IAsyncResult2 {
3 object AsyncState {get;} //獲取用戶定義的對(duì)象，它限定或包含關(guān)于異步操作的信息。
4 WailHandle AsyncWaitHandle {get;} //獲取用于等待異步操作完成的 WaitHandle。
5 bool CompletedSynchronously {get;} //獲取異步操作是否同步完成的指示。
6 bool IsCompleted {get;} //獲取異步操作是否已完成的指示。
7 }
通過(guò)輪詢方式，使用IsCompleted屬性判斷異步操作是否完成，這樣在異步操作未完成前就可以讓主線程執(zhí)行另外的工作。
1 class Program2 {
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)用委托，獲取計(jì)算結(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 }
運(yùn)行結(jié)果：
?
除此以外，也可以使用WailHandle完成同樣的工作，WaitHandle里面包含有一個(gè)方法WaitOne（int timeout），它可以判斷委托是否完成工作，在工作未完成前主線程可以繼續(xù)其他工作。運(yùn)行下面代碼可得到與使用 IAsyncResult.IsCompleted 同樣的結(jié)果，而且更簡(jiǎn)單方便 。
1 namespace Test2 {
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)用委托，獲取計(jì)算結(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 }
當(dāng)要監(jiān)視多個(gè)運(yùn)行對(duì)象的時(shí)候，使用IAsyncResult.WaitHandle.WaitOne可就派不上用場(chǎng)了。
幸好.NET為WaitHandle準(zhǔn)備了另外兩個(gè)靜態(tài)方法：WaitAny（waitHandle[], int）與WaitAll (waitHandle[] , int)。
其中WaitAll在等待所有waitHandle完成后再返回一個(gè)bool值。
而WaitAny是等待其中一個(gè)waitHandle完成后就返回一個(gè)int，這個(gè)int是代表已完成waitHandle在waitHandle[]中的數(shù)組索引。
下面就是使用WaitAll的例子，運(yùn)行結(jié)果與使用 IAsyncResult.IsCompleted 相同。
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)用委托，獲取計(jì)算結(jié)果
13 IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
14
15 //此處可加入多個(gè)檢測(cè)對(duì)象
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ù)
使用輪詢方式來(lái)檢測(cè)異步方法的狀態(tài)非常麻煩，而且效率不高，有見(jiàn)及此，.NET為 IAsyncResult BeginInvoke（AsyncCallback , object）準(zhǔn)備了一個(gè)回調(diào)函數(shù)。使用 AsyncCallback 就可以綁定一個(gè)方法作為回調(diào)函數(shù)，回調(diào)函數(shù)必須是帶參數(shù) IAsyncResult 且無(wú)返回值的方法： void AsycnCallbackMethod(IAsyncResult result) 。在BeginInvoke方法完成后，系統(tǒng)就會(huì)調(diào)用AsyncCallback所綁定的回調(diào)函數(shù),最后回調(diào)函數(shù)中調(diào)用 XXX EndInvoke（IAsyncResult result) 就可以結(jié)束異步方法，它的返回值類型與委托的返回值一致。
1 class Program2 {
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)用委托，獲取計(jì)算結(jié)果
12 myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), null);
13 //在啟動(dòng)異步線程后，主線程可以繼續(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 //獲取委托對(duì)象，調(diào)用EndInvoke方法獲取運(yùn)行結(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í)行其他命令，而無(wú)需再等待了，這無(wú)疑比使用輪詢方式判斷異步方法是否完成更有優(yōu)勢(shì)。
在異步方法執(zhí)行完成后將會(huì)調(diào)用AsyncCallback所綁定的回調(diào)函數(shù)，注意一點(diǎn)，回調(diào)函數(shù)依然是在異步線程中執(zhí)行，這樣就不會(huì)影響主線程的運(yùn)行，這也使用回調(diào)函數(shù)最值得青昧的地方。
在回調(diào)函數(shù)中有一個(gè)既定的參數(shù)IAsyncResult,把IAsyncResult強(qiáng)制轉(zhuǎn)換為AsyncResult后，就可以通過(guò) AsyncResult.AsyncDelegate 獲取原委托，再使用EndInvoke方法獲取計(jì)算結(jié)果。
運(yùn)行結(jié)果如下：
如果想為回調(diào)函數(shù)傳送一些外部信息，就可以利用BeginInvoke(AsyncCallback,object)的最后一個(gè)參數(shù)object,它允許外部向回調(diào)函數(shù)輸入任何類型的參數(shù)。只需要在回調(diào)函數(shù)中利用 AsyncResult.AsyncState 就可以獲取object對(duì)象。
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對(duì)象
19 Person person = new Person();
20 person.Name = "Elva";
21 person.Age = 27;
22
23 //異步調(diào)用委托，輸入?yún)?shù)對(duì)象person, 獲取計(jì)算結(jié)果
24 myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), person);
25
26 //在啟動(dòng)異步線程后，主線程可以繼續(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 //獲取委托對(duì)象，調(diào)用EndInvoke方法獲取運(yùn)行結(jié)果
46 AsyncResult _result = (AsyncResult)result;
47 MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
48 string data = myDelegate.EndInvoke(_result);
49 //獲取Person對(duì)象
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 }
運(yùn)行結(jié)果:
?
轉(zhuǎn)載于:https://www.cnblogs.com/ywsoftware/p/3147668.html
總結(jié)
以上是生活随笔為你收集整理的C#综合揭秘——细说多线程（上）的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。
- 上一篇： Reading——The Non-Des
- 下一篇： indigo egit