C#的多線程機制探索下

大家可以看到，在上面的常式中，同步是通過等待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; using System.Collections; using System.Threading; //這是用來儲存資訊的資料結構，將作為參數被傳遞 public class SomeState { 　　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)HashCount[Thread.CurrentThread.GetHashCode()])+1; 　　} 　　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 100 1 : 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; 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()方法把它設定為無訊號狀態。這裡用它的有訊號狀態來表示一個線程的結束。

// Mutex.cs 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#是一種新的語言，因此它的線程機制也有許多獨特的地方，希望大家能通過本文清楚地看到這些，從而可以對線程進行更深入的理解和探索。