注：本文中出現的代碼均在 .net Framework RC3 環境中運行通過 一 . 多線程的概念 Windows 是一個多任務的系統，如果你使用的是 windows 2000 及 其以上版本，你可以通過任務管理器查看當前系統運行的程序和進程。什么是進程呢？當一個程序開始運行時，它就是一個進程，進程所指包括運行中的程序和程序 所使用到的內存和系統資源。而一個進程又是由多個線程所組成的，線程是程序中的一個執行流，每個線程都有自己的專有寄存器 ( 棧指針、程序計數器等 ) ，但代碼區是共享的，即不同的線程可以執行同樣的函數。多線程是指程序中包含多個執行流，即在一個程序中可以同時運行多個不同的線程來執行不同的任務，也就是說允許單個程序創建多個并行執行的線程來完成各自的任務。瀏覽器就是一個很好的多線程的例子 , 在瀏覽器中你可以在下載 JAVA 小應用程序或圖象的同時滾動頁面 , 在訪問新頁面時 , 播放動畫和聲音 , 打印文件等。 多線程的好處在于可以提高 CPU 的利用率 —— 任何一個程序員都不希望自己的程序很多時候沒事可干，在多線程程序中，一個線程必須等待的時候， CPU 可以運行其它的線程而不是等待，這樣就大大提高了程序的效率。 然而我們也必須認識到線程本身可能影響系統性能的不利方面，以正確使用線程： 線程也是程序，所以線程需要占用內存，線程越多占用內存也越多 多線程需要協調和管理，所以需要 CPU 時間跟蹤線程 線程之間對共享資源的訪問會相互影響，必須解決競用共享資源的問題 線程太多會導致控制太復雜，最終可能造成很多 Bug 基 于以上認識，我們可以一個比喻來加深理解。假設有一個公司，公司里有很多各司其職的職員，那么我們可以認為這個正常運作的公司就是一個進程，而公司里的職 員就是線程。一個公司至少得有一個職員吧，同理，一個進程至少包含一個線程。在公司里，你可以一個職員干所有的事，但是效率很顯然是高不起來的，一個人的 公司也不可能做大；一個程序中也可以只用一個線程去做事，事實上，一些過時的語言如 fortune,basic 都是如此，但是象一個人的公司一樣，效率很低，如果做大程序，效率更低 —— 事實上現在幾乎沒有單線程的商業軟件。公司的職員越多，老板就得發越多的薪水給他們，還得耗費大量精力去管理他們，協調他們之間的矛盾和利益；程序也是如此，線程越多耗費的資源也越多，需要 CPU 時間去跟蹤線程，還得解決諸如死鎖，同步等問題。總之，如果你不想你的公司被稱為 “ 皮包公司 ” ，你就得多幾個員工；如果你不想讓你的程序顯得稚氣，就在你的程序里引入多線程吧！ 本文將對 C# 編程中的多線程機制進行探討，通過一些實例解決對線程的控制，多線程間通訊等問題。為了省去創建 GUI 那些繁瑣的步驟，更清晰地逼近線程的本質，下面所有的程序都是控制臺程序，程序最后的 Console.ReadLine() 是為了使程序中途停下來，以便看清楚執行過程中的輸出。 好了，廢話少說，讓我們來體驗一下多線程的 C# 吧！ 二 . 操縱一個線程 任何程序在執行時，至少有一個主線程，下面這段小程序可以給讀者一個直觀的印象：
//SystemThread.cs class RunIt { [STAThread] static void Main(string[] args) { Thread.CurrentThread.Name="System Thread";// 給當前線程起名為 "System Thread" Console.ReadLine(); } }
編譯執行后你看到了什么？是的，程序將產生如下輸出： System Thread's Status:Running 在這里，我們通過 Thread 類的靜態屬性 CurrentThread 獲取了當前執行的線程，對其 Name 屬性賦值 “System Thread” ，最后還輸出了它的當前狀態（ ThreadState ）。所謂靜態屬性，就是這個類所有對象所公有的屬性，不管你創建了多少個這個類的實例，但是類的靜態屬性在內存中只有一個。很容易理解 CurrentThread 為什么是靜態的 —— 雖然有多個線程同時存在，但是在某一個時刻， CPU 只能執行其中一個。 就像上面程序所演示的，我們通過 Thread 類來創建和控制線程。注意到程序的頭部，我們使用了如下命名空間：
using System; using System.Threading;
在 .net framework class library 中，所有與多線程機制應用相關的類都是放在 System.Threading 命名空間中的。其中提供 Thread 類用于創建線程， ThreadPool 類用于管理線程池等等，此外還提供解決了線程執行安排，死鎖，線程間通訊等實際問題的機制。如果你想在你的應用程序中使用多線程，就必須包含這個類。 Thread 類有幾個至關重要的方法，描述如下：
Start(): 啟動線程 Sleep(int): 靜態方法，暫停當前線程指定的毫秒數 Abort(): 通常使用該方法來終止一個線程 Suspend() ：該方法并不終止未完成的線程，它僅僅掛起線程，以后還可恢復。 Resume(): 恢復被 Suspend() 方法掛起的線程的執行 1
下面我們就動手來創建一個線程，使用 Thread 類創建線程時，只需提供線程入口即可。線程入口使程序知道該讓這個線程干什么事，在 C# 中，線程入口是通過 ThreadStart 代理（ delegate ）來提供的，你可以把 ThreadStart 理解為一個函數指針，指向線程要執行的函數，當調用 Thread.Start() 方法后，線程就開始執行 ThreadStart 所代表或者說指向的函數。 打開你的 VS.net ，新建一個控制臺應用程序（ Console Application ），下面這些代碼將讓你體味到完全控制一個線程的無窮樂趣！
//ThreadTest.cs using System; using System.Threading; namespace ThreadTest { public class Alpha { public void Beta() { while (true) { Console.WriteLine("Alpha.Beta is running in its own thread."); } } }; public class Simple { public static int Main() { Console.WriteLine("Thread Start/Stop/Join Sample"); Alpha oAlpha = new Alpha(); file:// 這里創建一個線程，使之執行 Alpha 類的 Beta() 方法 Thread oThread = new Thread(new ThreadStart(oAlpha.Beta)); oThread.Start(); while (!oThread.IsAlive); Thread.Sleep(1); oThread.Abort(); oThread.Join(); Console.WriteLine(); Console.WriteLine("Alpha.Beta has finished"); try { Console.WriteLine("Try to restart the Alpha.Beta thread"); oThread.Start(); } catch (ThreadStateException) { Console.Write("ThreadStateException trying to restart Alpha.Beta. "); Console.WriteLine("Expected since aborted threads cannot be restarted."); Console.ReadLine(); } return 0; } } }
這段程序包含兩個類 Alpha 和 Simple ，在創建線程 oThread 時我們用指向 Alpha.Beta() 方法的初始化了 ThreadStart 代理（ delegate ）對象，當我們創建的線程 oThread 調用 oThread.Start() 方法啟動時，實際上程序運行的是 Alpha.Beta() 方法：
Alpha oAlpha = new Alpha(); Thread oThread = new Thread(new ThreadStart(oAlpha.Beta)); oThread.Start();
然后在 Main() 函數的 while 循環中，我們使用靜態方法 Thread.Sleep() 讓主線程停了 1ms ，這段時間 CPU 轉向執行線程 oThread 。然后我們試圖用 Thread.Abort() 方法終止線程 oThread ，注意后面的 oThread.Join() ， Thread.Join() 方法使主線程等待，直到 oThread 線程結束。你可以給 Thread.Join() 方法指定一個 int 型的參數作為等待的最長時間。之后，我們試圖用 Thread.Start() 方法重新啟動線程 oThread ，但是顯然 Abort() 方法帶來的后果是不可恢復的終止線程，所以最后程序會拋出 ThreadStateException 異常。 程序最后得到的結果將如下圖：
?
在這里我們要注意的是其它線程都是依附于 Main() 函數所在的線程的， Main() 函數是 C# 程序的入口，起始線程可以稱之為主線程，如果所有的前臺線程都停止了，那么主線程可以終止，而所有的后臺線程都將無條件終止。而所有的線程雖然在微觀上是串行執行的，但是在宏觀上你完全可以認為它們在并行執行。 讀者一定注意到了 Thread.ThreadState 這個屬性，這個屬性代表了線程運行時狀態，在不同的情況下有不同的值，于是我們有時候可以通過對該值的判斷來設計程序流程。 ThreadState 在各種情況下的可能取值如下：
Aborted ：線程已停止 AbortRequested ：線程的 Thread.Abort() 方法已被調用，但是線程還未停止 Background ：線程在后臺執行，與屬性 Thread.IsBackground 有關 Running ：線程正在正常運行 Stopped ：線程已經被停止 StopRequested ：線程正在被要求停止 Suspended ：線程已經被掛起（此狀態下，可以通過調用 Resume() 方法重新運行） SuspendRequested ：線程正在要求被掛起，但是未來得及響應 Unstarted ：未調用 Thread.Start() 開始線程的運行 WaitSleepJoin ：線程因為調用了 Wait(),Sleep() 或 Join() 等方法處于封鎖狀態 上面提到了 Background 狀態表示該線程在后臺運行，那么后臺運行的線程有什么特別的地方呢？其實后臺線程跟前臺線程只有一個區別，那就是后臺線程不妨礙程序的終止。一旦一個進程所有的前臺線程都終止后， CLR （通用語言運行環境）將通過調用任意一個存活中的后臺進程的 Abort() 方法來徹底終止進程。 當線程之間爭奪 CPU 時間時， CPU 按照是線程的優先級給予服務的。在 C# 應用程序中，用戶可以設定 5 個不同的優先級，由高到低分別是 Highest ， AboveNormal ， Normal ， BelowNormal ， Lowest ，在創建線程時如果不指定優先級，那么系統默認為 ThreadPriority.Normal 。給一個線程指定優先級 ，我們可以使用如下代碼：
// 設定優先級為最低
通過設定線程的優先級，我們可以安排一些相對重要的線程優先執行，例如對用戶的響應等等。 現在我們對怎樣創建和控制一個線程已經有了一個初步的了解，下面我們將深入研究線程實現中比較典型的的問題，并且探討其解決方法。 三 . 線程的同步和通訊 —— 生產者和消費者 假 設這樣一種情況，兩個線程同時維護一個隊列，如果一個線程對隊列中添加元素，而另外一個線程從隊列中取用元素，那么我們稱添加元素的線程為生產者，稱取用 元素的線程為消費者。生產者與消費者問題看起來很簡單，但是卻是多線程應用中一個必須解決的問題，它涉及到線程之間的同步和通訊問題。 前面說過，每個線程都有自己的資源，但是代碼區是共享的，即每個線程都可以執行相同的函數。但是多線程環境下，可能帶來的問題就是幾個線程同時執行一個函數，導致數據的混亂，產生不可預料的結果，因此我們必須避免這種情況的發生。 C# 提供了一個關鍵字 lock ，它可以把一段代碼定義為互斥段（ critical section ），互斥段在一個時刻內只允許一個線程進入執行，而其他線程必須等待。在 C# 中，關鍵字 lock 定義如下：
expression 代表你希望跟蹤的對象，通常是對象引用。一般地，如果你想保護一個類的實例，你可以使用 this ；如果你希望保護一個靜態變量（如互斥代碼段在一個靜態方法內部），一般使用類名就可以了。而 statement_block 就是互斥段的代碼，這段代碼在一個時刻內只可能被一個線程執行。 下面是一個使用 lock 關鍵字的典型例子，我將在注釋里向大家說明 lock 關鍵字的用法和用途：
//lock.cs using System; internal class Account { int balance; Random r = new Random(); internal Account(int initial) { balance = initial; } internal int Withdraw(int amount) { if (balance < 0) { file:// 如果 balance 小于 0 則拋出異常 throw new Exception("Negative Balance"); } // 下面的代碼保證在當前線程修改 balance 的值完成之前 // 不會有其他線程也執行這段代碼來修改 balance 的值 // 因此， balance 的值是不可能小于 0 的 lock (this) { Console.WriteLine("Current Thread:"+Thread.CurrentThread.Name); file:// 如果沒有 lock 關鍵字的保護，那么可能在執行完 if 的條件判斷之后 file:// 另外一個線程卻執行了 balance=balance-amount 修改了 balance 的值 file:// 而這個修改對這個線程是不可見的，所以可能導致這時 if 的條件已經不成立了 file:// 但是，這個線程卻繼續執行 balance=balance-amount ，所以導致 balance 可能小于 0 if (balance >= amount) { Thread.Sleep(5); balance = balance - amount; return amount; } else { return 0; // transaction rejected } } } internal void DoTransactions() { for (int i = 0; i < 100; i++) Withdraw(r.Next(-50, 100)); } internal class Test { static internal Thread[] threads = new Thread[10]; public static void Main() { Account acc = new Account (0); for (int i = 0; i < 10; i++) { Thread t = new Thread(new ThreadStart(acc.DoTransactions)); threads[i] = t; } for (int i = 0; i < 10; i++) threads[i].Name=i.ToString(); for (int i = 0; i < 10; i++) threads[i].Start(); Console.ReadLine(); }
而多線程公用一個對象時，也會出現和公用代碼類似的問題，這種問題就不應該使用 lock 關鍵字了，這里需要用到 System.Threading 中的一個類 Monitor ，我們可以稱之為監視器， Monitor 提供了使線程共享資源的方案。 Monitor 類可以鎖定一個對象，一個線程只有得到這把鎖才可以對該對象進行操作。對象鎖機制保證了在可能引起混亂的情況下一個時刻只有一個線程可以訪問這個對象。 Monitor 必須和一個具體的對象相關聯，但是由于它是一個靜態的類，所以不能使用它來定義對象，而且它的所有方法都是靜態的，不能使用對象來引用。下面代碼說明了使用 Monitor 鎖定一個對象的情形：
...... Queue oQueue=new Queue(); Monitor.Enter(oQueue); ......// 現在 oQueue 對象只能被當前線程操縱了 釋放鎖
如上所示，當一個線程調用 Monitor.Enter() 方法鎖定一個對象時，這個對象就歸它所有了，其它線程想要訪問這個對象，只有等待它使用 Monitor.Exit() 方法釋放鎖。為了保證線程最終都能釋放鎖，你可以把 Monitor.Exit() 方法寫在 try-catch-finally 結構中的 finally 代碼塊里。對于任何一個被 Monitor 鎖定的對象，內存中都保存著與它相關的一些信息，其一是現在持有鎖的線程的引用，其二是一個預備隊列，隊列中保存了已經準備好獲取鎖的線程，其三是一個等待隊列，隊列中保存著當前正在等待這個對象狀態改變的隊列的引用。當擁有對象鎖的線程準備釋放鎖時，它使用 Monitor.Pulse() 方法通知等待隊列中的第一個線程，于是該線程被轉移到預備隊列中，當對象鎖被釋放時，在預備隊列中的線程可以立即獲得對象鎖。 下面是一個展示如何使用 lock 關鍵字和 Monitor 類來實現線程的同步和通訊的例子，也是一個典型的生產者與消費者問題。這個例程中，生產者線程和消費者線程是交替進行的，生產者寫入一個數，消費者立即讀取并且顯示，我將在注釋中介紹該程序的精要所在。用到的系統命名空間如下：
using System; using System.Threading;
首先，我們定義一個被操作的對象的類 Cell ，在這個類里，有兩個方法： ReadFromCell() 和 WriteToCell 。消費者線程將調用 ReadFromCell() 讀取 cellContents 的內容并且顯示出來，生產者進程將調用 WriteToCell() 方法向 cellContents 寫入數據。
public class Cell { int cellContents; // Cell 對象里邊的內容 bool readerFlag = false; // 狀態標志，為 true 時可以讀取，為 false 則正在寫入 public int ReadFromCell( ) { lock(this) // Lock 關鍵字保證了什么，請大家看前面對 lock 的介紹 { if (!readerFlag)// 如果現在不可讀取 { try { file:// 等待 WriteToCell 方法中調用 Monitor.Pulse() 方法 Monitor.Wait(this); } catch (SynchronizationLockException e) { Console.WriteLine(e); } catch (ThreadInterruptedException e) { Console.WriteLine(e); } } Console.WriteLine("Consume: {0}",cellContents); readerFlag = false; file:// 重置 readerFlag 標志，表示消費行為已經完成 Monitor.Pulse(this); file:// 通知 WriteToCell() 方法（該方法在另外一個線程中執行，等待中） } return cellContents; } public void WriteToCell(int n) { lock(this) { if (readerFlag) { try { Monitor.Wait(this); } catch (SynchronizationLockException e) { file:// 當同步方法（指 Monitor 類除 Enter 之外的方法）在非同步的代碼區被調用 Console.WriteLine(e); } catch (ThreadInterruptedException e) { file:// 當線程在等待狀態的時候中止 Console.WriteLine(e); } } cellContents = n; Console.WriteLine("Produce: {0}",cellContents); readerFlag = true; Monitor.Pulse(this); file:// 通知另外一個線程中正在等待的 ReadFromCell() 方法 } }
下面定義生產者 CellProd 和消費者類 CellCons ，它們都只有一個方法 ThreadRun() ，以便在 Main() 函數中提供給線程的 ThreadStart 代理對象，作為線程的入口。
public class CellProd { Cell cell; // 被操作的 Cell 對象 int quantity = 1; // 生產者生產次數，初始化為 1 public CellProd(Cell box, int request) { // 構造函數 cell = box; quantity = request; } public void ThreadRun( ) { for(int looper=1; looper<=quantity; looper++) cell.WriteToCell(looper); file:// 生產者向操作對象寫入信息 } public class CellCons { Cell cell; int quantity = 1; public CellCons(Cell box, int request) { cell = box; quantity = request; } public void ThreadRun( ) { int valReturned; for(int looper=1; looper<=quantity; looper++) valReturned=cell.ReadFromCell( );// 消費者從操作對象中讀取信息 }
然后在下面這個類 MonitorSample 的 Main() 函數中我們要做的就是創建兩個線程分別作為生產者和消費者，使用 CellProd.ThreadRun() 方法和 CellCons.ThreadRun() 方法對同一個 Cell 對象進行操作。
public class MonitorSample { public static void Main(String[] args) { int result = 0; file:// 一個標志位，如果是 0 表示程序沒有出錯，如果是 1 表明有錯誤發生 Cell cell = new Cell( ); // 下面使用 cell 初始化 CellProd 和 CellCons 兩個類，生產和消費次數均為 20 次 CellProd prod = new CellProd(cell, 20); CellCons cons = new CellCons(cell, 20); Thread producer = new Thread(new ThreadStart(prod.ThreadRun)); Thread consumer = new Thread(new ThreadStart(cons.ThreadRun)); // 生產者線程和消費者線程都已經被創建，但是沒有開始執行 try { producer.Start( ); consumer.Start( ); producer.Join( ); consumer.Join( ); Console.ReadLine(); } catch (ThreadStateException e) { file:// 當線程因為所處狀態的原因而不能執行被請求的操作 Console.WriteLine(e); result = 1; } catch (ThreadInterruptedException e) { file:// 當線程在等待狀態的時候中止 Console.WriteLine(e); result = 1; } // 盡管 Main() 函數沒有返回值，但下面這條語句可以向父進程返回執行結果 Environment.ExitCode = result; }
大家可以看到，在上面的例程中，同步是通過等待 Monitor.Pulse() 來完成的。首先生產者生產了一個值，而同一時刻消費者處于等待狀態，直到收到生產者的 “ 脈沖 (Pulse)” 通知它生產已經完成，此后消費者進入消費狀態，而生產者開始等待消費者完成操作后將調用 Monitor.Pulese() 發出的 “ 脈沖 ” 。它的執行結果很簡單：
Produce: 1 Consume: 1 Produce: 2 Consume: 2 Produce: 3 Consume: 3 ... ... Produce: 20 Consume: 20
事實上，這個簡單的例子已經幫助我們解決了多線程應用程序中可能出現的大問題，只要領悟了解決線程間沖突的基本方法，很容易把它應用到比較復雜的程序中去。 四、線程池和定時器 —— 多線程的自動管理 在多線程的程序中，經常會出現兩種情況。一種情況下，應用程序中的線程把大部分的時間花費在等待狀態，等待某個事件發生，然后才能給予響應；而另外一種情況則是線程平常都處于休眠狀態，只是周期性地被喚醒。在 .net framework 里邊，我們使用 ThreadPool 來對付第一種情況，使用 Timer 來對付第二種情況。 ThreadPool 類提供一個由系統維護的線程池 —— 可以看作一個線程的容器，該容器需要 Windows 2000 以上版本的系統支持，因為其中某些方法調用了只有高版本的 Windows 才有的 API 函數。你可以使用 ThreadPool.QueueUserWorkItem() 方法將線程安放在線程池里，該方法的原型如下： // 將一個線程放進線程池，該線程的 Start() 方法將調用 WaitCallback 代理對象代表的函數 public static bool QueueUserWorkItem(WaitCallback); // 重載的方法如下，參數 object 將傳遞給 WaitCallback 所代表的方法 public static bool QueueUserWorkItem(WaitCallback, object); 要注意的是， ThreadPool 類也是一個靜態類，你不能也不必要生成它的對象，而且一旦使用該方法在線程池中添加了一個項目，那么該項目將是沒有辦法取消的。在這里你無需自己建立線程，只需把你要做的工作寫成函數，然后作為參數傳遞給 ThreadPool.QueueUserWorkItem() 方法就行了，傳遞的方法就是依靠 WaitCallback 代理對象，而線程的建立、管理、運行等等工作都是由系統自動完成的，你無須考慮那些復雜的細節問題，線程池的優點也就在這里體現出來了，就好像你是公司老板 —— 只需要安排工作，而不必親自動手。
下面的例程演示了 ThreadPool 的用法。首先程序創建了一個 ManualResetEvent 對象，該對象就像一個信號燈，可以利用它的信號來通知其它線程，本例中當線程池中所有線程工作都完成以后， ManualResetEvent 的對象將被設置為有信號，從而通知主線程繼續運行。它有幾個重要的方法： Reset() ， Set() ， WaitOne() 。初始化該對象時，用戶可以指定其默認的狀態（有信號 / 無信號），在初始化以后，該對象將保持原來的狀態不變直到它的 Reset() 或者 Set() 方法被調用， Reset() 方法將其設置為無信號狀態， Set() 方法將其設置為有信號狀態。 WaitOne() 方法使當前線程掛起直到 ManualResetEvent 對象處于有信號狀態，此時該線程將被激活。然后，程序將向線程池中添加工作項，這些以函數形式提供的工作項被系統用來初始化自動建立的線程。當所有的線程都運行完了以后， ManualResetEvent.Set() 方法被調用，因為調用了 ManualResetEvent.WaitOne() 方法而處在等待狀態的主線程將接收到這個信號，于是它接著往下執行，完成后邊的工作。
using System.Threading; // 這是用來保存信息的數據結構，將作為參數被傳遞 { public int Cookie; public SomeState(int iCookie) { Cookie = iCookie; } public class Alpha { public Hashtable HashCount; public ManualResetEvent eventX; public static int iCount = 0; public static int iMaxCount = 0; public Alpha(int MaxCount) { HashCount = new Hashtable(MaxCount); iMaxCount = MaxCount; } file:// 線程池里的線程將調用 Beta() 方法 public void Beta(Object state) { // 輸出當前線程的 hash 編碼值和 Cookie 的值 Console.WriteLine(" {0} {1} :", Thread.CurrentThread.GetHashCode(), ((SomeState)state).Cookie); Console.WriteLine("HashCount.Count=={0}, Thread.CurrentThread.GetHashCode()=={1}", HashCount.Count, Thread.CurrentThread.GetHashCode()); lock (HashCount) { file:// 如果當前的 Hash 表中沒有當前線程的 Hash 值，則添加之 if (!HashCount.ContainsKey(Thread.CurrentThread.GetHashCode())) HashCount.Add (Thread.CurrentThread.GetHashCode(), 0); HashCount[Thread.CurrentThread.GetHashCode()] = } int iX = 2000; Thread.Sleep(iX); //Interlocked.Increment() 操作是一個原子操作，具體請看下面說明 Interlocked.Increment(ref iCount); if (iCount == iMaxCount) { Console.WriteLine(); Console.WriteLine("Setting eventX "); eventX.Set(); } } public class SimplePool { public static int Main(string[] args) { Console.WriteLine("Thread Pool Sample:"); bool W2K = false; int MaxCount = 10;// 允許線程池中運行最多 10 個線程 // 新建 ManualResetEvent 對象并且初始化為無信號狀態 ManualResetEvent eventX = new ManualResetEvent(false); Console.WriteLine("Queuing {0} items to Thread Pool", MaxCount); Alpha oAlpha = new Alpha(MaxCount); file:// 創建工作項 // 注意初始化 oAlpha 對象的 eventX 屬性 oAlpha.eventX = eventX; Console.WriteLine("Queue to Thread Pool 0"); try { file:// 將工作項裝入線程池 file:// 這里要用到 Windows 2000 以上版本才有的 API ，所以可能出現 NotSupportException 異常 ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta), new SomeState(0)); W2K = true; } catch (NotSupportedException) { Console.WriteLine("These API's may fail when called on a non-Windows 2000 system."); W2K = false; } if (W2K)// 如果當前系統支持 ThreadPool 的方法 . { for (int iItem=1;iItem < MaxCount;iItem++) { // 插入隊列元素 Console.WriteLine("Queue to Thread Pool {0}", iItem); ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta),new SomeState(iItem)); } Console.WriteLine("Waiting for Thread Pool to drain"); file:// 等待事件的完成，即線程調用 ManualResetEvent.Set() 方法 eventX.WaitOne(Timeout.Infinite,true); file://WaitOne() 方法使調用它的線程等待直到 eventX.Set() 方法被調用 Console.WriteLine("Thread Pool has been drained (Event fired)"); Console.WriteLine(); Console.WriteLine("Load across threads"); foreach(object o in oAlpha.HashCount.Keys) Console.WriteLine("{0} {1}", o, oAlpha.HashCount[o]); } Console.ReadLine(); return 0; }
程序中有些小地方應該引起我們的注意。 SomeState 類是一個保存信息的數據結構，在上面的程序中，它作為參數被傳遞給每一個線程，你很容易就能理解這個，因為你需要把一些有用的信息封裝起來提供給線程，而這種方式是非常有效的。程序出現的 InterLocked 類也是專為多線程程序而存在的，它提供了一些有用的原子操作，所謂原子操作就是在多線程程序中，如果這個線程調用這個操作修改一個變量，那么其他線程就不能修改這個變量了，這跟 lock 關鍵字在本質上是一樣的。 我們應該徹底地分析上面的程序，把握住線程池的本質，理解它存在的意義是什么，這樣我們才能得心應手地使用它。下面是該程序的輸出結果：
Thread Pool Sample: Queuing 10 items to Thread Pool Queue to Thread Pool 0 Queue to Thread Pool 1 ... ... Queue to Thread Pool 9 Waiting for Thread Pool to drain 98 0 : HashCount.Count==0, Thread.CurrentThread.GetHashCode()==98 HashCount.Count==1, Thread.CurrentThread.GetHashCode()==100 98 2 : ... ... Setting eventX Thread Pool has been drained (Event fired) Load across threads 101 2 100 3 98 4 102 1
與 ThreadPool 類不同， Timer 類的作用是設置一個定時器，定時執行用戶指定的函數，而這個函數的傳遞是靠另外一個代理對象 TimerCallback ，它必須在創建 Timer 對象時就指定，并且不能更改。定時器啟動后，系統將自動建立一個新的線程，并且在這個線程里執行用戶指定的函數。下面的語句初始化了一個 Timer 對象：
Timer timer = new Timer(timerDelegate, s,1000, 1000);
第一個參數指定了 TimerCallback 代理對象；第二個參數的意義跟上面提到的 WaitCallback 代理對象的一樣，作為一個傳遞數據的對象傳遞給要調用的方法；第三個參數是延遲時間 —— 計時開始的時刻距現在的時間，單位是毫秒；第四個參數是定時器的時間間隔 —— 計時開始以后，每隔這么長的一段時間， TimerCallback 所代表的方法將被調用一次，單位也是毫秒。這句話的意思就是將定時器的延遲時間和時間間隔都設為 1 秒鐘。 定時器的設置是可以改變的，只要調用 Timer.Change() 方法，這是一個參數類型重載的方法，一般使用的原型如下：
public bool Change(long, long);
下面這段代碼將前邊設置的定時器修改了一下：
timer.Change(10000,2000);
很顯然，定時器 timer 的時間間隔被重新設置為 2 秒，停止計時 10 秒后生效。 下面這段程序演示了 Timer 類的用法。
using System.Threading; class TimerExampleState { public int counter = 0; public Timer tmr; class App { public static void Main() { TimerExampleState s = new TimerExampleState(); // 創建代理對象 TimerCallback ，該代理將被定時調用 TimerCallback timerDelegate = new TimerCallback(CheckStatus); // 創建一個時間間隔為 1s 的定時器 Timer timer = new Timer(timerDelegate, s,1000, 1000); s.tmr = timer; // 主線程停下來等待 Timer 對象的終止 while(s.tmr != null) Thread.Sleep(0); Console.WriteLine("Timer example done."); Console.ReadLine(); } file:// 下面是被定時調用的方法 static void CheckStatus(Object state) { TimerExampleState s =(TimerExampleState)state; s.counter++; Console.WriteLine("{0} Checking Status {1}.",DateTime.Now.TimeOfDay, s.counter); if(s.counter == 5) { file:// 使用 Change 方法改變了時間間隔 (s.tmr).Change(10000,2000); Console.WriteLine("changed..."); } if(s.counter == 10) { Console.WriteLine("disposing of timer..."); s.tmr.Dispose(); s.tmr = null; } }
程序首先創建了一個定時器，它將在創建 1 秒之后開始每隔 1 秒調用一次 CheckStatus() 方法，當調用 5 次以后，在 CheckStatus() 方法中修改了時間間隔為 2 秒，并且指定在 10 秒后重新開始。當計數達到 10 次，調用 Timer.Dispose() 方法刪除了 timer 對象，主線程于是跳出循環，終止程序。程序執行的結果如下：
上面就是對 ThreadPool 和 Timer 兩個類的簡單介紹，充分利用系統提供的功能，可以為我們省去很多時間和精力 —— 特別是對很容易出錯的多線程程序。同時我們也可以看到 .net Framework 強大的內置對象，這些將對我們的編程帶來莫大的方便。
、互斥對象 —— 更加靈活的同步方式 有 時候你會覺得上面介紹的方法好像不夠用，對，我們解決了代碼和資源的同步問題，解決了多線程自動化管理和定時觸發的問題，但是如何控制多個線程相互之間的 聯系呢？例如我要到餐廳吃飯，在吃飯之前我先得等待廚師把飯菜做好，之后我開始吃飯，吃完我還得付款，付款方式可以是現金，也可以是信用卡，付款之后我才 能離開。分析一下這個過程，我吃飯可以看作是主線程，廚師做飯又是一個線程，服務員用信用卡收款和收現金可以看作另外兩個線程，大家可以很清楚地看到其中 的關系 —— 我吃飯必須等待廚師做飯，然后等待兩個收款線程之中任意一個的完成，然后我吃飯這個線程可以執行離開這個步驟，于是我吃飯才算結束了。事實上，現實中有著比這更復雜的聯系，我們怎樣才能很好地控制它們而不產生沖突和重復呢？ 這種情況下，我們需要用到互斥對象，即 System.Threading 命名空間中的 Mutex 類。大家一定坐過出租車吧，事實上我們可以把 Mutex 看作一個出租車，那么乘客就是線程了，乘客首先得等車，然后上車，最后下車，當一個乘客在車上時，其他乘客就只有等他下車以后才可以上車。而線程與 Mutex 對象的關系也正是如此，線程使用 Mutex.WaitOne() 方法等待 Mutex 對象被釋放，如果它等待的 Mutex 對象被釋放了，它就自動擁有這個對象，直到它調用 Mutex.ReleaseMutex() 方法釋放這個對象，而在此期間，其他想要獲取這個 Mutex 對象的線程都只有等待。 下面這個例子使用了 Mutex 對象來同步四個線程，主線程等待四個線程的結束，而這四個線程的運行又是與兩個 Mutex 對象相關聯的。其中還用到 AutoResetEvent 類的對象，如同上面提到的 ManualResetEvent 對象一樣，大家可以把它簡單地理解為一個信號燈，使用 AutoResetEvent.Set() 方法可以設置它為有信號狀態，而使用 AutoResetEvent.Reset() 方法把它設置為無信號狀態。這里用它的有信號狀態來表示一個線程的結束。
using System; using System.Threading; public class MutexSample { static Mutex gM1; static Mutex gM2; const int ITERS = 100; static AutoResetEvent Event1 = new AutoResetEvent(false); static AutoResetEvent Event2 = new AutoResetEvent(false); static AutoResetEvent Event3 = new AutoResetEvent(false); static AutoResetEvent Event4 = new AutoResetEvent(false); public static void Main(String[] args) { Console.WriteLine("Mutex Sample ..."); // 創建一個 Mutex 對象，并且命名為 MyMutex gM1 = new Mutex(true,"MyMutex"); // 創建一個未命名的 Mutex 對象 . gM2 = new Mutex(true); Console.WriteLine(" - Main Owns gM1 and gM2"); AutoResetEvent[] evs = new AutoResetEvent[4]; evs[0] = Event1; file:// 為后面的線程 t1,t2,t3,t4 定義 AutoResetEvent 對象 evs[1] = Event2; evs[2] = Event3; evs[3] = Event4; MutexSample tm = new MutexSample( ); Thread t1 = new Thread(new ThreadStart(tm.t1Start)); Thread t2 = new Thread(new ThreadStart(tm.t2Start)); Thread t3 = new Thread(new ThreadStart(tm.t3Start)); Thread t4 = new Thread(new ThreadStart(tm.t4Start)); t1.Start( );// 使用 Mutex.WaitAll() 方法等待一個 Mutex 數組中的對象全部被釋放 t2.Start( );// 使用 Mutex.WaitOne() 方法等待 gM1 的釋放 t3.Start( );// 使用 Mutex.WaitAny() 方法等待一個 Mutex 數組中任意一個對象被釋放 t4.Start( );// 使用 Mutex.WaitOne() 方法等待 gM2 的釋放 Thread.Sleep(2000); Console.WriteLine(" - Main releases gM1"); gM1.ReleaseMutex( ); file:// 線程 t2,t3 結束條件滿足 Thread.Sleep(1000); Console.WriteLine(" - Main releases gM2"); gM2.ReleaseMutex( ); file:// 線程 t1,t4 結束條件滿足 // 等待所有四個線程結束 WaitHandle.WaitAll(evs); Console.WriteLine("... Mutex Sample"); Console.ReadLine(); } public void t1Start( ) { Console.WriteLine("t1Start started, Mutex.WaitAll(Mutex[])"); Mutex[] gMs = new Mutex[2]; gMs[0] = gM1;// 創建一個 Mutex 數組作為 Mutex.WaitAll() 方法的參數 gMs[1] = gM2; Mutex.WaitAll(gMs);// 等待 gM1 和 gM2 都被釋放 Thread.Sleep(2000); Console.WriteLine("t1Start finished, Mutex.WaitAll(Mutex[]) satisfied"); Event1.Set( ); file:// 線程結束，將 Event1 設置為有信號狀態 } public void t2Start( ) { Console.WriteLine("t2Start started, gM1.WaitOne( )"); gM1.WaitOne( );// 等待 gM1 的釋放 Console.WriteLine("t2Start finished, gM1.WaitOne( ) satisfied"); Event2.Set( );// 線程結束，將 Event2 設置為有信號狀態 } public void t3Start( ) { Console.WriteLine("t3Start started, Mutex.WaitAny(Mutex[])"); Mutex[] gMs = new Mutex[2]; gMs[0] = gM1;// 創建一個 Mutex 數組作為 Mutex.WaitAny() 方法的參數 gMs[1] = gM2; Mutex.WaitAny(gMs);// 等待數組中任意一個 Mutex 對象被釋放 Console.WriteLine("t3Start finished, Mutex.WaitAny(Mutex[])"); Event3.Set( );// 線程結束，將 Event3 設置為有信號狀態 } public void t4Start( ) { Console.WriteLine("t4Start started, gM2.WaitOne( )"); gM2.WaitOne( );// 等待 gM2 被釋放 Console.WriteLine("t4Start finished, gM2.WaitOne( )"); Event4.Set( );// 線程結束，將 Event4 設置為有信號狀態 }
下面是該程序的執行結果：
從執行結果可以很清楚地看到，線程 t2,t3 的運行是以 gM1 的釋放為條件的，而 t4 在 gM2 釋放后開始執行， t1 則在 gM1 和 gM2 都被釋放了之后才執行。 Main() 函數最后，使用 WaitHandle 等待所有的 AutoResetEvent 對象的信號，這些對象的信號代表相應線程的結束。 六、小結 多線程程序設計是一個龐大的主題，而本文試圖在 .net Framework 環境下，使用最新的 C# 語言來描述多線程程序的概貌。希望本文能有助于大家理解線程這種概念，理解多線程的用途，理解它的 C# 實現方法，理解線程將為我們帶來的好處和麻煩。 C# 是一種新的語言，因此它的線程機制也有許多獨特的地方，希望大家能通過本文清楚地看到這些，從而可以對線程進行更深入的理解和探索。
轉載于:https://www.cnblogs.com/AloneSword/archive/2006/02/25/2237633.html
總結
以上是生活随笔 為你收集整理的C#的多线程（2）——机制探索 的全部內容，希望文章能夠幫你解決所遇到的問題。
如果覺得生活随笔 網站內容還不錯，歡迎將生活随笔 推薦給好友。
