c#.net 多線程編程學習（1） 收藏 http://blog.csdn.net/coon32/archive/2008/11/24/3364974.aspx
引言
早期的計算硬件十分復雜,但是操作系統(tǒng)執(zhí)行的功能確十分的簡單。那個時候的操作系統(tǒng)在任一時間點只能執(zhí)行一個任務(wù),也就是同一時間只能執(zhí)行一個程序。多個任務(wù)的執(zhí)行必須得輪流執(zhí)行,在系統(tǒng)里面進行排隊等候。由于計算機的發(fā)展,要求系統(tǒng)功能越來越強大，這個時候出現(xiàn)了分時操作的概念：每個運行的程序占有一定的處理機時間,當這個占有時間結(jié)束后,在等待隊列等待處理器資源的下一個程序就開始投入運行。注意這里的程序在占有一定的處理器時間后并沒有運行完畢，可能需要再一次或多次分配處理器時間。那么從這里可以看出，這樣的執(zhí)行方式顯然是多個程序的并行執(zhí)行，但是在宏觀上，我們感覺到多個任務(wù)是同時執(zhí)行的，因此多任務(wù)的概念就誕生了。每個運行的程序都有自己的內(nèi)存空間,自己的堆棧和環(huán)境變量設(shè)置。每一個程序?qū)?yīng)一個進程，代表著執(zhí)行一個大的任務(wù)。一個進程可以啟動另外一個進程,這個被啟動的進程稱為子進程。父進程和子進程的執(zhí)行只有邏輯上的先后關(guān)系，并沒有其他的關(guān)系，也就是說他們的執(zhí)行是獨立的。但是，可能一個大的程序（代表著一個大的任務(wù)）,可以分割成很多的小任務(wù)，為了功能上的需要也有可能是為了加快運行的速度，可能需要同一時間執(zhí)行多個任務(wù)(每個任務(wù)分配一個多線程來執(zhí)行相應(yīng)的任務(wù))。舉個例子來說,你正在通過你的web瀏覽器查看一些精彩的文章，你需要把好的文章給下載下來，可能有些非常精彩的文章你需要收藏起來，你就用你的打印機打印這些在線的文章。在這里，瀏覽器一邊下載HTML格式的文章，一邊還要打印文章。這就是一個程序同時執(zhí)行多個任務(wù)，每個任務(wù)分配一個線程來完成。因此我們可以看出一個程序同時執(zhí)行多個任務(wù)的能力是通過多線程來實現(xiàn)的。
多線程VS多任務(wù)
正如上面所說的,多任務(wù)是相對與操作系統(tǒng)而言,指的是同一時間執(zhí)行多個程序的能力,雖然這么說,但是實際上在只有一個CPU的條件下不可能同時執(zhí)行兩個以上的程序。CPU在程序之間做高速的切換,使得所有的程序在很短的時間之內(nèi)可以得到更小的CPU時間,這樣從用戶的角度來看就好象是同時在執(zhí)行多個程序。多線程相對于操作系統(tǒng)而言,指的是可以同時執(zhí)行同一個程序的不同部分的能力,每個執(zhí)行的部分被成為線程。所以在編寫應(yīng)用程序時,我們必須得很好的設(shè)計以 避免不同的線程執(zhí)行時的相互干擾。這樣有助于我們設(shè)計健壯的程序,使得我們可以在隨時需要的時候添加線程。
線程的概念
線程可以被描述為一個微進程,它擁有起點,執(zhí)行的順序系列和一個終點。它負責維護自己的堆棧,這些堆棧用于異常處理,優(yōu)先級調(diào)度和其他一些系統(tǒng)重新恢復線程執(zhí)行時需要的信息。從這個概念看來，好像線程與進程沒有任何的區(qū)別，實際上線程與進程是肯定有區(qū)別的：
一個完整的進程擁有自己獨立的內(nèi)存空間和數(shù)據(jù),但是同一個進程內(nèi)的線程是共享內(nèi)存空間和數(shù)據(jù)的。一個進程對應(yīng)著一段程序,它是由一些在同一個程序里面獨立的同時的運行的線程組成的。線程有時也被稱為并行運行在程序里的輕量級進程,線程被稱為是輕量級進程是因為它的運行依賴與進程提供的上下文環(huán)境,并且使用的是進程的資源。
在一個進程里,線程的調(diào)度有搶占式或者非搶占的模式。
在搶占模式下，操作系統(tǒng)負責分配ＣＰＵ時間給各個進程，一旦當前的進程使用完分配給自己的ＣＰＵ時間，操作系統(tǒng)將決定下一個占用ＣＰＵ時間的是哪一個線程。因此操作系統(tǒng)將定期的中斷當前正在執(zhí)行的線程，將ＣＰＵ分配給在等待隊列的下一個線程。所以任何一個線程都不能獨占ＣＰＵ。每個線程占用ＣＰＵ的時間取決于進程和操作系統(tǒng)。進程分配給每個線程的時間很短,以至于我們感覺所有的線程是同時執(zhí)行的。實際上,系統(tǒng)運行每個進程的時間有2毫秒,然后調(diào)度其他的線程。它同時他維持著所有的線程和循環(huán),分配很少量的ＣＰＵ時間給線程。 線程的的切換和調(diào)度是如此之快,以至于感覺是所有的線程是同步執(zhí)行的。
調(diào)度是什么意思?調(diào)度意味著處理器存儲著將要執(zhí)行完ＣＰＵ時間的進程的狀態(tài)和將來某個時間裝載這個進程的狀態(tài)而恢復其運行。然而這種方式也有不足之處,一個線程可以在任何給定的時間中斷另外一個線程的執(zhí)行。假設(shè)一個線程正在向一個文件做寫操作,而另外一個線程中斷其運行,也向同一個文件做寫操作。 Windows 95/NT, UNIX使用的就是這種線程調(diào)度方式。
在非搶占的調(diào)度模式下,每個線程可以需要ＣＰＵ多少時間就占用ＣＰＵ多少時間。在這種調(diào)度方式下,可能一個執(zhí)行時間很長的線程使得其他所有需要ＣＰＵ的線程”餓死”。在處理機空閑，即該進程沒有使用ＣＰＵ時，系統(tǒng)可以允許其他的進程暫時使用ＣＰＵ。占用ＣＰＵ的線程擁有對ＣＰＵ的控制權(quán)，只有它自己主動釋放ＣＰＵ時，其他的線程才可以使用ＣＰＵ。一些I/O和Windows 3。x就是使用這種調(diào)度策略。
在有些操作系統(tǒng)里面，這兩種調(diào)度策略都會用到。非搶占的調(diào)度策略在線程運行優(yōu)先級一般時用到，而對于高優(yōu)先級的線程調(diào)度則多采用搶占式的調(diào)度策略。如果你不確定系統(tǒng)采用的是那種調(diào)度策略，假設(shè)搶占的調(diào)度策略不可用是比較安全的。在設(shè)計應(yīng)用程序的時候，我們認為那些占用ＣＰＵ時間比較多的線程在一定的間隔是會釋放ＣＰＵ的控制權(quán)的，這時候系統(tǒng)會查看那些在等待隊列里面的與當前運行的線程同一優(yōu)先級或者更高的優(yōu)先級的線程，而讓這些線程得以使用ＣＰＵ。如果系統(tǒng)找到一個這樣的線程，就立即暫停當前執(zhí)行的線程和激活滿足條件的線程。如果沒有找到同一優(yōu)先級或更高級的線程，當前線程還繼續(xù)占有ＣＰＵ。當正在執(zhí)行的線程想釋放ＣＰＵ的控制權(quán)給一個低優(yōu)先級的線程，當前線程就轉(zhuǎn)入睡眠狀態(tài)而讓低優(yōu)先級的線程占有ＣＰＵ。
在多處理器系統(tǒng)，操作系統(tǒng)會將這些獨立的線程分配給不同的處理器執(zhí)行，這樣將會大大的加快程序的運行。線程執(zhí)行的效率也會得到很大的提高，因為將線程的分時共享單處理器變成了分布式的多處理器執(zhí)行。這種多處理器在三維建模和圖形處理是非常有用的。
需要多線程嗎
我們發(fā)出了一個打印的命令，要求打印機進行打印任務(wù)，假設(shè)這時候計算機停止了響應(yīng)而打印機還在工作，那豈不是我們的停止手上的事情就等著這慢速的打印機打??？所幸的是，這種情況不會發(fā)生，我們在打印機工作的時候還可以同時聽音樂或者畫圖。因為我們使用了獨立的多線程來執(zhí)行這些任務(wù)。你可能會對多個用戶同時訪問數(shù)據(jù)庫或者web服務(wù)器感到吃驚，他們是怎么工作的？這是因為為每個連接到數(shù)據(jù)庫或者web服務(wù)器的用戶建立了獨立的線程來維護用戶的狀態(tài)。如果一個程序的運行有一定的順序，這時候采用這種方式可能會出現(xiàn)問題，甚至導致整個程序崩潰。如果程序可以分成獨立的不同的任務(wù)，使用多線程，即使某一部分任務(wù)失敗了，對其他的也沒有影響，不會導致整個程序崩潰。
毫無疑問的是，編寫多線程程序使得你有了一個利器可以駕奴非多線程的程序，但是多線程也可能成為一個負擔或者需要不小的代價。如果使用的不當，會帶來更多的壞處。如果一個程序有很多的線程，那么其他程序的線程必然只能占用更少的ＣＰＵ時間；而且大量的ＣＰＵ時間是用于線程調(diào)度的；操作系統(tǒng)也需要足夠的內(nèi)存空間來維護每個線程的上下文信息；因此，大量的線程會降低系統(tǒng)的運行效率。因此，如果使用多線程的話，程序的多線程必須設(shè)計的很好，否則帶來的好處將遠小于壞處。因此使用多線程我們必須小心的處理這些線程的創(chuàng)建，調(diào)度和釋放工作。
多線程程序設(shè)計提示
有多種方法可以設(shè)計多線程的應(yīng)用程序。正如后面的文章所示，我將給出詳細的編程示例，通過這些例子，你將可以更好的理解多線程。線程可以有不同的優(yōu)先級，舉例子來說，在我們的應(yīng)用程序里面，繪制圖形或者做大量運算的同時要接受用戶的輸入，顯然用戶的輸入需要得到第一時間的響應(yīng)，而圖形繪制或者運算則需要大量的時間，暫停一下問題不大，因此用戶輸入線程將需要高的悠閑級，而圖形繪制或者運算低優(yōu)先級即可。這些線程之間相互獨立，相互不影響。
在上面的例子中，圖形繪制或者大量的運算顯然是需要站用很多的ＣＰＵ時間的，在這段時間，用戶沒有必要等著他們執(zhí)行完畢再輸入信息，因此我們將程序設(shè)計成獨立的兩個線程，一個負責用戶的輸入，一個負責處理那些耗時很長的任務(wù)。這將使得程序更加靈活，能夠快速響應(yīng)。同時也可以使得用戶在運行的任何時候取消任務(wù)的可能。在這個繪制圖形的例子中，程序應(yīng)該始終負責接收系統(tǒng)發(fā)來的消息。如果由于程序忙于一個任務(wù)，有可能會導致屏幕變成空白，這顯然需要我們的程序來處理這樣的事件。所以我必須得有一個線程負責來處理這些消息，正如剛才所說的應(yīng)該觸發(fā)重畫屏幕的工作。
我們應(yīng)該把握一個原則，對于那些對時間要求比較緊迫需要立即得到相應(yīng)的任務(wù)，我們因該給予高的優(yōu)先級，而其他的線程優(yōu)先級應(yīng)該低于她的優(yōu)先級。偵聽客戶端請求的線程應(yīng)該始終是高的優(yōu)先級，對于一個與用戶交互的用戶界面的任務(wù)來說，它需要得到第一時間的響應(yīng)，其優(yōu)先級因該高優(yōu)先級。
發(fā)表于 @ 2008年11月24日 22:44:00 | 評論( 0 ) | 舉報| 收藏
c#.net 多線程編程學習（2） 收藏 http://blog.csdn.net/coon32/archive/2008/11/24/3364997.aspx
Thread類
在.NET中編寫的程序?qū)⒈蛔詣拥姆峙湟粋€線程.讓我們來看看用C#編程語言創(chuàng)建線程并且繼續(xù)學習線程的知識。我們都知道.NET的運行時環(huán)境的主線程由Main ()方法來啟動應(yīng)用程序，而且.NET的編譯語言有自動的垃圾收集功能,這個垃圾收集發(fā)生在另外一個線程里面,所有的這些都是后臺發(fā)生的,讓我們無法感覺到發(fā)生了什么事情.在這里默認的是只有一個線程來完成所有的程序任務(wù)，但是正如我們在第一篇文章討論過的一樣，有可能我們根據(jù)需要自己添加更多的線程讓程序更好的協(xié)調(diào)工作。比如說我們的例子中，一個有用戶輸入的同時需要繪制圖形或者完成大量的運算的程序，我們必須得增加一個線程，讓用戶的輸入能夠得到及時的響應(yīng)，因為輸入對時間和響應(yīng)的要求是緊迫的，而另外一個線程負責圖形繪制或者大量的運算。
.NET 基礎(chǔ)類庫的System.Threading命名空間提供了大量的類和接口支持多線程。這個命名空間有很多的類，我們將在這里著重討論Thread這個類。
System.Threading.Thread類是創(chuàng)建并控制線程，設(shè)置其優(yōu)先級并獲取其狀態(tài)最為常用的類。他有很多的方法，在這里我們將就比較常用和重要的方法做一下介紹：
Thread.Start（）：啟動線程的執(zhí)行；
Thread.Suspend（）：掛起線程，或者如果線程已掛起，則不起作用；
Thread.Resume（）：繼續(xù)已掛起的線程；
Thread.Interrupt（）：中止處于 Wait或者Sleep或者Join 線程狀態(tài)的線程；
Thread.Join（）：阻塞調(diào)用線程，直到某個線程終止時為止
Thread.Sleep（）：將當前線程阻塞指定的毫秒數(shù)；
Thread.Abort（）：以開始終止此線程的過程。如果線程已經(jīng)在終止，則不能通過Thread.Start（）來啟動線程。
通過調(diào)用Thread.Sleep，Thread.Suspend或者Thread.Join可以暫停/阻塞線程。調(diào)用Sleep()和Suspend()方法意味著線程將不再得到CPU時間。這兩種暫停線程的方法是有區(qū)別的，Sleep()使得線程立即停止執(zhí)行，但是在調(diào)用Suspend()方法之前，公共語言運行時必須到達一個安全點。一個線程不能對另外一個線程調(diào)用Sleep()方法，但是可以調(diào)用Suspend()方法使得另外一個線程暫停執(zhí)行。對已經(jīng)掛起的線程調(diào)用Thread.Resume（）方法會使其繼續(xù)執(zhí)行。不管使用多少次Suspend()方法來阻塞一個線程，只需一次調(diào)用Resume()方法就可以使得線程繼續(xù)執(zhí)行。已經(jīng)終止的和還沒有開始執(zhí)行的線程都不能使用掛起。Thread.Sleep（int x）使線程阻塞x毫秒。只有當該線程是被其他的線程通過調(diào)用Thread.Interrupt（）或者Thread.Abort（）方法，才能被喚醒。
如果對處于阻塞狀態(tài)的線程調(diào)用Thread.Interrupt（）方法將使線程狀態(tài)改變，但是會拋出ThreadInterupptedException異常，你可以捕獲這個異常并且做出處理，也可以忽略這個異常而讓運行時終止線程。在一定的等待時間之內(nèi)，Thread.Interrupt（）和Thread.Abort（）都可以立即喚醒一個線程。
下面我們將說明如何從一個線程中止另外一個線程。在這種情況下，我們可以通過使用Thread.Abort（）方法來永久銷毀一個線程，而且將拋出ThreadAbortException異常。使終結(jié)的線程可以捕獲到異常但是很難控制恢復，僅有的辦法是調(diào)用Thread.ResetAbort（）來取消剛才的調(diào)用，而且只有當這個異常是由于被調(diào)用線程引起的異常。因此，A線程可以正確的使用Thread.Abort（）方法作用于B線程，但是B線程卻不能調(diào)用Thread.ResetAbort（）來取消Thread.Abort（）操作。
Thread.Abort（）方法使得系統(tǒng)悄悄的銷毀了線程而且不通知用戶。一旦實施Thread.Abort（）操作，該線程不能被重新啟動。調(diào)用了這個方法并不是意味著線程立即銷毀，因此為了確定線程是否被銷毀，我們可以調(diào)用Thread.Join（）來確定其銷毀，Thread.Join（）是一個阻塞調(diào)用，直到線程的確是終止了才返回。但是有可能一個線程調(diào)用Thread.Interrupt（）方法來中止另外一個線程，而這個線程正在等待Thread.Join（）調(diào)用的返回。
盡可能的不要用Suspend()方法來掛起阻塞線程，因為這樣很容易造成死鎖。假設(shè)你掛起了一個線程，而這個線程的資源是其他線程所需要的，會發(fā)生什么后果。因此，我們盡可能的給重要性不同的線程以不同的優(yōu)先級，用Thread.Priority（）方法來代替使用Thread.Suspend（）方法。
Thread類有很多的屬性，這些重要的屬性是我們多線程編程必須得掌握的。
Thread.IsAlive屬性：獲取一個值，該值指示當前線程的執(zhí)行狀態(tài)。如果此線程已啟動并且尚未正常終止或中止，則為 true；否則為 false。
Thread.Name 屬性：獲取或設(shè)置線程的名稱。
Thread.Priority 屬性：獲取或設(shè)置一個值，該值指示線程的調(diào)度優(yōu)先級。
Thread.ThreadState 屬性：獲取一個值，該值包含當前線程的狀態(tài)。
在下面的例子中，我們將看看怎么設(shè)置這些屬性，在隨后的例子中我們將詳細的討論這些屬性。
創(chuàng)建一個線程，首先得實例化一個Thread類，在類得構(gòu)造函數(shù)中調(diào)用ThreadStart委派。這個委派包含了線程從哪里開始執(zhí)行。當線程啟動后，Start()方法啟動一個新的線程。下面是例子程序。
using System;
using System.Threading ;
namespace LearnThreads
{
class Thread_App
{
public static void First_Thread()
{
Console.WriteLine("First thread created");
Thread current_thread = Thread.CurrentThread;
string thread_details = "Thread Name: " + current_thread.Name + "\r\nThread State: " + current_thread.ThreadState.ToString()+"\r\n Thread Priority level:"+current_thread.Priority.ToString();
Console.WriteLine("The details of the thread are :"+ thread_details);
Console.WriteLine ("first thread terminated");
}
public static void Main()
{
ThreadStart thr_start_func = new ThreadStart (First_Thread);
Console.WriteLine ("Creating the first thread ");
Thread fThread = new Thread (thr_start_func);
fThread.Name = "first_thread";
fThread.Start (); //starting the thread
}
}
}
在這個例子中，創(chuàng)建了一個fThread的線程對象，這個線程負責執(zhí)行First_Thread()方法里面的任務(wù)。當Thread的Start() 方法被調(diào)用時包含F(xiàn)irst_Thread()的地址ThreadStart的代理將被執(zhí)行。
Thread狀態(tài)
System.Threading.Thread.ThreadState屬性定義了執(zhí)行時線程的狀態(tài)。線程從創(chuàng)建到線程終止，它一定處于其中某一個狀態(tài)。當線程被創(chuàng)建時，它處在Unstarted狀態(tài)，Thread類的Start() 方法將使線程狀態(tài)變?yōu)镽unning狀態(tài)，線程將一直處于這樣的狀態(tài)，除非我們調(diào)用了相應(yīng)的方法使其掛起、阻塞、銷毀或者自然終止。如果線程被掛起，它將處于Suspended狀態(tài)，除非我們調(diào)用resume（）方法使其重新執(zhí)行，這時候線程將重新變?yōu)镽unning狀態(tài)。一旦線程被銷毀或者終止，線程處于Stopped狀態(tài)。處于這個狀態(tài)的線程將不復存在，正如線程開始啟動，線程將不可能回到Unstarted狀態(tài)。線程還有一個Background狀態(tài)，它表明線程運行在前臺還是后臺。在一個確定的時間，線程可能處于多個狀態(tài)。據(jù)例子來說，一個線程被調(diào)用了Sleep而處于阻塞，而接著另外一個線程調(diào)用Abort方法于這個阻塞的線程，這時候線程將同時處于WaitSleepJoin和AbortRequested狀態(tài)。一旦線程響應(yīng)轉(zhuǎn)為Sle阻塞或者中止，當銷毀時會拋出ThreadAbortException異常。
線程優(yōu)先級
System.Threading.Thread.Priority枚舉了線程的優(yōu)先級別，從而決定了線程能夠得到多少CPU時間。高優(yōu)先級的線程通常會比一般優(yōu)先級的線程得到更多的CPU時間，如果不止一個高優(yōu)先級的線程，操作系統(tǒng)將在這些線程之間循環(huán)分配CPU時間。低優(yōu)先級的線程得到的CPU時間相對較少，當這里沒有高優(yōu)先級的線程，操作系統(tǒng)將挑選下一個低優(yōu)先級 的線程執(zhí)行。一旦低優(yōu)先級的線程在執(zhí)行時遇到了高優(yōu)先級的線程，它將讓出CPU給高優(yōu)先級的線程。新創(chuàng)建的線程優(yōu)先級為一般優(yōu)先級，我們可以設(shè)置線程的優(yōu)先級別的值，如下面所示：
Highest
AboveNormal
Normal
BelowNormal
Lowest
線程同步
隨著對多線程學習的深入,你可能覺得需要了解一些有關(guān)線程共享資源的問題. .NET framework提供了很多的類和數(shù)據(jù)類型來控制對共享資源的訪問。
考慮一種我們經(jīng)常遇到的情況：有一些全局變量和共享的類變量，我們需要從不同的線程來更新它們，可以通過使用System.Threading.Interlocked類完成這樣的任務(wù)，它提供了原子的，非模塊化的整數(shù)更新操作。
還有你可以使用System.Threading.Monitor類鎖定對象的方法的一段代碼，使其暫時不能被別的線程訪問。
System.Threading.WaitHandle類的實例可以用來封裝等待對共享資源的獨占訪問權(quán)的操作系統(tǒng)特定的對象。尤其對于非受管代碼的互操作問題。
System.Threading.Mutex用于對多個復雜的線程同步的問題，它也允許單線程的訪問。
像ManualResetEvent和AutoResetEvent這樣的同步事件類支持一個類通知其他事件的線程。
不討論線程的同步問題，等于對多線程編程知之甚少，但是我們要十分謹慎的使用多線程的同步。在使用線程同步時，我們事先就要要能夠正確的確定是那個對象和方法有可能造成死鎖（死鎖就是所有的線程都停止了相應(yīng)，都在等者對方釋放資源）。還有贓數(shù)據(jù)的問題（指的是同一時間多個線程對數(shù)據(jù)作了操作而造成的不一致），這個不容易理解，這么說吧，有X和Y兩個線程，線程X從文件讀取數(shù)據(jù)并且寫數(shù)據(jù)到數(shù)據(jù)結(jié)構(gòu)，線程Y從這個數(shù)據(jù)結(jié)構(gòu)讀數(shù)據(jù)并將數(shù)據(jù)送到其他的計算機。假設(shè)在Y讀數(shù)據(jù)的同時，X寫入數(shù)據(jù)，那么顯然Y讀取的數(shù)據(jù)與實際存儲的數(shù)據(jù)是不一致的。這種情況顯然是我們應(yīng)該避免發(fā)生的。少量的線程將使得剛才的問題發(fā)生的幾率要少的多，對共享資源的訪問也更好的同步。
.NET Framework的CLR提供了三種方法來完成對共享資源 ，諸如全局變量域，特定的代碼段，靜態(tài)的和實例化的方法和域。
?。?） 代碼域同步：使用Monitor類可以同步靜態(tài)/實例化的方法的全部代碼或者部分代碼段。不支持靜態(tài)域的同步。在實例化的方法中，this指針用于同步；而在靜態(tài)的方法中，類用于同步，這在后面會講到。
?。?） 手工同步：使用不同的同步類（諸如WaitHandle, Mutex, ReaderWriterLock, ManualResetEvent, AutoResetEvent 和Interlocked等）創(chuàng)建自己的同步機制。這種同步方式要求你自己手動的為不同的域和方法同步，這種同步方式也可以用于進程間的同步和對共享資源的等待而造成的死鎖解除。
?。?） 上下文同步：使用SynchronizationAttribute為ContextBoundObject對象創(chuàng)建簡單的，自動的同步。這種同步方式僅用于實例化的方法和域的同步。所有在同一個上下文域的對象共享同一個鎖。
Monitor Class
在給定的時間和指定的代碼段只能被一個線程訪問，Monitor 類非常適合于這種情況的線程同步。這個類中的方法都是靜態(tài)的，所以不需要實例化這個類。下面一些靜態(tài)的方法提供了一種機制用來同步對象的訪問從而避免死鎖和維護數(shù)據(jù)的一致性。
Monitor.Enter 方法：在指定對象上獲取排他鎖。
Monitor.TryEnter 方法：試圖獲取指定對象的排他鎖。
Monitor.Exit 方法：釋放指定對象上的排他鎖。
Monitor.Wait 方法：釋放對象上的鎖并阻塞當前線程，直到它重新獲取該鎖。
Monitor.Pulse 方法：通知等待隊列中的線程鎖定對象狀態(tài)的更改。
Monitor.PulseAll 方法：通知所有的等待線程對象狀態(tài)的更改。
通過對指定對象的加鎖和解鎖可以同步代碼段的訪問。Monitor.Enter, Monitor.TryEnter 和 Monitor.Exit用來對指定對象的加鎖和解鎖。一旦獲?。ㄕ{(diào)用了Monitor.Enter）指定對象（代碼段）的鎖，其他的線程都不能獲取該鎖。舉個例子來說吧，線程X獲得了一個對象鎖，這個對象鎖可以釋放的（調(diào)用Monitor.Exit(object) or Monitor.Wait）。當這個對象鎖被釋放后，Monitor.Pulse方法和 Monitor.PulseAll方法通知就緒隊列的下一個線程進行和其他所有就緒隊列的線程將有機會獲取排他鎖。線程X釋放了鎖而線程Y獲得了鎖，同時調(diào)用Monitor.Wait的線程X進入等待隊列。當從當前鎖定對象的線程（線程Y）受到了Pulse或PulseAll，等待隊列的線程就進入就緒隊列。線程X重新得到對象鎖時，Monitor.Wait才返回。如果擁有鎖的線程（線程Y）不調(diào)用Pulse或PulseAll，方法可能被不確定的鎖定。Pulse, PulseAll and Wait必須是被同步的代碼段鄂被調(diào)用。對每一個同步的對象，你需要有當前擁有鎖的線程的指針，就緒隊列和等待隊列（包含需要被通知鎖定對象的狀態(tài)變化的線程）的指針。
你也許會問，當兩個線程同時調(diào)用Monitor.Enter會發(fā)生什么事情？無論這兩個線程地調(diào)用Monitor.Enter是多么地接近，實際上肯定有一個在前，一個在后，因此永遠只會有一個獲得對象鎖。既然Monitor.Enter是原子操作，那么CPU是不可能偏好一個線程而不喜歡另外一個線程的。為了獲取更好的性能，你應(yīng)該延遲后一個線程的獲取鎖調(diào)用和立即釋放前一個線程的對象鎖。對于private和internal的對象，加鎖是可行的，但是對于external對象有可能導致死鎖，因為不相關(guān)的代碼可能因為不同的目的而對同一個對象加鎖。
如果你要對一段代碼加鎖，最好的是在try語句里面加入設(shè)置鎖的語句，而將Monitor.Exit放在finally語句里面。對于整個代碼段的加鎖，你可以使用MethodImplAttribute（在System.Runtime.CompilerServices命名空間）類在其構(gòu)造器中設(shè)置同步值。這是一種可以替代的方法，當加鎖的方法返回時，鎖也就被釋放了。如果需要要很快釋放鎖，你可以使用Monitor類和C# lock的聲明代替上述的方法。
讓我們來看一段使用Monitor類的代碼：
public void some_method()
{
int a=100;
int b=0;
Monitor.Enter(this);
//say we do something here.
int c=a/b;
Monitor.Exit(this);
}
上面的代碼運行會產(chǎn)生問題。當代碼運行到int c=a/b; 的時候，會拋出一個異常，Monitor.Exit將不會返回。因此這段程序?qū)炱穑渌木€程也將得不到鎖。有兩種方法可以解決上面的問題。第一個方法是：將代碼放入try…finally內(nèi)，在finally調(diào)用Monitor.Exit，這樣的話最后一定會釋放鎖。第二種方法是：利用C#的lock（）方法。調(diào)用這個方法和調(diào)用Monitoy.Enter的作用效果是一樣的。但是這種方法一旦代碼執(zhí)行超出范圍，釋放鎖將不會自動的發(fā)生。見下面的代碼:
public void some_method()
{
int a=100;
int b=0;
lock(this);
//say we do something here.
int c=a/b;
}
C# lock申明提供了與Monitoy.Enter和Monitoy.Exit同樣的功能，這種方法用在你的代碼段不能被其他獨立的線程中斷的情況。
WaitHandle Class
WaitHandle類作為基類來使用的，它允許多個等待操作。這個類封裝了win32的同步處理方法。WaitHandle對象通知其他的線程它需要對資源排他性的訪問，其他的線程必須等待，直到WaitHandle不再使用資源和等待句柄沒有被使用。下面是從它繼承來的幾個類：
Mutex 類：同步基元也可用于進程間同步。
AutoResetEvent：通知一個或多個正在等待的線程已發(fā)生事件。無法繼承此類。
ManualResetEvent：當通知一個或多個正在等待的線程事件已發(fā)生時出現(xiàn)。無法繼承此類。
這些類定義了一些信號機制使得對資源排他性訪問的占有和釋放。他們有兩種狀態(tài)：signaled 和 nonsignaled。Signaled狀態(tài)的等待句柄不屬于任何線程，除非是nonsignaled狀態(tài)。擁有等待句柄的線程不再使用等待句柄時用set方法，其他的線程可以調(diào)用Reset方法來改變狀態(tài)或者任意一個WaitHandle方法要求擁有等待句柄，這些方法見下面：
WaitAll：等待指定數(shù)組中的所有元素收到信號。
WaitAny：等待指定數(shù)組中的任一元素收到信號。
WaitOne：當在派生類中重寫時，阻塞當前線程，直到當前的 WaitHandle 收到信號。
這些wait方法阻塞線程直到一個或者更多的同步對象收到信號。
WaitHandle對象封裝等待對共享資源的獨占訪問權(quán)的操作系統(tǒng)特定的對象無論是收管代碼還是非受管代碼都可以使用。但是它沒有Monitor使用輕便，Monitor是完全的受管代碼而且對操作系統(tǒng)資源的使用非常有效率。
Mutex Class
Mutex是另外一種完成線程間和跨進程同步的方法，它同時也提供進程間的同步。它允許一個線程獨占共享資源的同時阻止其他線程和進程的訪問。Mutex的名字就很好的說明了它的所有者對資源的排他性的占有。一旦一個線程擁有了Mutex，想得到Mutex的其他線程都將掛起直到占有線程釋放它。Mutex.ReleaseMutex方法用于釋放Mutex，一個線程可以多次調(diào)用wait方法來請求同一個Mutex，但是在釋放Mutex的時候必須調(diào)用同樣次數(shù)的Mutex.ReleaseMutex。如果沒有線程占有Mutex，那么Mutex的狀態(tài)就變?yōu)閟ignaled，否則為nosignaled。一旦Mutex的狀態(tài)變?yōu)閟ignaled，等待隊列的下一個線程將會得到Mutex。Mutex類對應(yīng)與win32的CreateMutex，創(chuàng)建Mutex對象的方法非常簡單，常用的有下面幾種方法：
一個線程可以通過調(diào)用WaitHandle.WaitOne 或 WaitHandle.WaitAny 或 WaitHandle.WaitAll得到Mutex的擁有權(quán)。如果Mutex不屬于任何線程，上述調(diào)用將使得線程擁有Mutex，而且WaitOne會立即返回。但是如果有其他的線程擁有Mutex，WaitOne將陷入無限期的等待直到獲取Mutex。你可以在WaitOne方法中指定參數(shù)即等待的時間而避免無限期的等待Mutex。調(diào)用Close作用于Mutex將釋放擁有。一旦Mutex被創(chuàng)建，你可以通過GetHandle方法獲得Mutex的句柄而給WaitHandle.WaitAny 或 WaitHandle.WaitAll 方法使用。
下面是一個示例：
public void some_method()
{
int a=100;
int b=20;
Mutex firstMutex = new Mutex(false);
FirstMutex.WaitOne();
//some kind of processing can be done here.
Int x=a/b;
FirstMutex.Close();
}
在上面的例子中，線程創(chuàng)建了Mutex，但是開始并沒有申明擁有它，通過調(diào)用WaitOne方法擁有Mutex。
Synchronization Events
同步時間是一些等待句柄用來通知其他的線程發(fā)生了什么事情和資源是可用的。他們有兩個狀態(tài)：signaled and nonsignaled。AutoResetEvent 和 ManualResetEvent就是這種同步事件。
AutoResetEvent Class
這個類可以通知一個或多個線程發(fā)生事件。當一個等待線程得到釋放時，它將狀態(tài)轉(zhuǎn)換為signaled。用set方法使它的實例狀態(tài)變?yōu)閟ignaled。但是一旦等待的線程被通知時間變?yōu)閟ignaled，它的轉(zhuǎn)臺將自動的變?yōu)閚onsignaled。如果沒有線程偵聽事件，轉(zhuǎn)臺將保持為signaled。此類不能被繼承。
ManualResetEvent Class
這個類也用來通知一個或多個線程事件發(fā)生了。它的狀態(tài)可以手動的被設(shè)置和重置。手動重置時間將保持signaled狀態(tài)直到ManualResetEvent.Reset設(shè)置其狀態(tài)為nonsignaled，或保持狀態(tài)為nonsignaled直到ManualResetEvent.Set設(shè)置其狀態(tài)為signaled。這個類不能被繼承。
Interlocked Class
它提供了在線程之間共享的變量訪問的同步，它的操作時原子操作，且被線程共享.你可以通過Interlocked.Increment 或 Interlocked.Decrement來增加或減少共享變量.它的有點在于是原子操作,也就是說這些方法可以代一個整型的參數(shù)增量并且返回新的值,所有的操作就是一步.你也可以使用它來指定變量的值或者檢查兩個變量是否相等,如果相等,將用指定的值代替其中一個變量的值.
ReaderWriterLock class
它定義了一種鎖,提供唯一寫/多讀的機制,使得讀寫的同步.任意數(shù)目的線程都可以讀數(shù)據(jù),數(shù)據(jù)鎖在有線程更新數(shù)據(jù)時將是需要的.讀的線程可以獲取鎖,當且僅當這里沒有寫的線程.當沒有讀線程和其他的寫線程時,寫線程可以得到鎖.因此,一旦writer-lock被請求,所有的讀線程將不能讀取數(shù)據(jù)直到寫線程訪問完畢.它支持暫停而避免死鎖.它也支持嵌套的讀/寫鎖.支持嵌套的讀鎖的方法是ReaderWriterLock.AcquireReaderLock,如果一個線程有寫鎖則該線程將暫停;
支持嵌套的寫鎖的方法是ReaderWriterLock.AcquireWriterLock,如果一個線程有讀鎖則該線程暫停.如果有讀鎖將容易倒是死鎖.安全的辦法是使用ReaderWriterLock.UpgradeToWriterLock方法,這將使讀者升級到寫者.你可以用ReaderWriterLock.DowngradeFromWriterLock方法使寫者降級為讀者.調(diào)用ReaderWriterLock.ReleaseLock將釋放鎖, ReaderWriterLock.RestoreLock將重新裝載鎖的狀態(tài)到調(diào)用ReaderWriterLock.ReleaseLock以前.
線程池和異步編程
如果你仔細閱讀了我前面的三篇文章,我相信你對用.NET Framework提供的System.Threading.Thread類和一些線程同步的類基本的線程知識和多線程編程知識很了解。我們將在這里進一步討論一些.NET類,以及他們在多線程編程中扮演的角色和怎么編程。它們是:
System.Threading.ThreadPool 類
System.Threading.Timer 類
如果線程的數(shù)目并不是很多,而且你想控制每個線程的細節(jié)諸如線程的優(yōu)先級等,使用Thread是比較合適的;但是如果有大量的線程,考慮使用線程池應(yīng)該更好一些,它提供了高效的線程管理機制來處理多任務(wù)。 對于定期的執(zhí)行任務(wù)Timer類是合適的;使用代表是異步方法調(diào)用的首選。
System.Threading.ThreadPool Class
當你創(chuàng)建應(yīng)用程序時,你應(yīng)該認識到大部分時間你的線程在空閑的等待某些事件的發(fā)生(諸如按下一個鍵或偵聽套節(jié)子的請求)。毫無疑問的,你也會認為這是絕對的浪費資源。
如果這里有很多的任務(wù)需要完成,每個任務(wù)需要一個線程,你應(yīng)該考慮使用線程池來更有效的管理你的資源并且從中受益。線程池是執(zhí)行的多個線程集合,它允許你添加以線程自動創(chuàng)建和開始的任務(wù)到隊列里面去。使用線程池使得你的系統(tǒng)可以優(yōu)化線程在CPU使用時的時間碎片。但是要記住在任何特定的時間點,每一個進程和每個線程池只有一個一個正在運行的線程。這個類使得你的線程組成的池可以被系統(tǒng)管理,而使你的主要精力集中在工作流的邏輯而不是線程的管理。
當?shù)谝淮螌嵗疶hreadPool類時線程池將被創(chuàng)建。它有一個默認的上限,即每處理器最多可以有25個,但是這個上限是可以改變的。這樣使得處理器不會閑置下來。如果其中一個線程等待某個事件的發(fā)生,線程池將初始化另外一個線程并投入處理器工作,線程池就是這樣不停的創(chuàng)建工作的線程和分配任務(wù)給那些沒有工作的在隊列里的線程。唯一的限制是工作線程的數(shù)目不能超過最大允許的數(shù)目。每個線程將運行在默認的優(yōu)先級和使用默認的屬于多線程空間的堆棧大小空間。一旦一項工作任務(wù)被加入隊列,你是不能取消的。
請求線程池處理一個任務(wù)或者工作項可以調(diào)用QueueUserWorkItem方法。這個方法帶一個WaitCallback代表類型的參數(shù),這個參數(shù)包裝了你藥完成的任務(wù)。運行時自動為每一個的任務(wù)創(chuàng)建線程并且在任務(wù)釋放時釋放線程。
下面的代碼說明了如何創(chuàng)建線程池和怎樣添加任務(wù):
public void afunction(object o)
{
// do what ever the function is supposed to do.
}
//thread entry code
{
// create an instance of WaitCallback
WaitCallback myCallback = new WaitCallback (afunction);
//add this to the thread pool / queue a task
ThreadPool.QueueUserWorkItem (myCallback);
}
你也可以通過調(diào)用ThreadPool.RegisterWaitForSingleObject方法來傳遞一個System.Threading.WaitHandle,當被通知或者時間超過了調(diào)用被System.Threading.WaitOrTimerCallback包裝的方法。
線程池和基于事件的編程模式使得線程池對注冊的WaitHandles的監(jiān)控和對合適的WaitOrTimerCallback代表方法的調(diào)用十分簡單(當WaitHandle被釋放時)。這些做法其實很簡單。這里有一個線程不斷的觀測在線程池隊列等待操作的狀態(tài)。一旦等待操作完成,一個線程將被執(zhí)行與其對應(yīng)的任務(wù)。因此,這個方法隨著出發(fā)觸發(fā)事件的發(fā)生而增加一個線程。
讓我們看看怎么隨事件添加一個線程到線程池,其實很簡單。我們只需要創(chuàng)建一個ManualResetEvent類的事件和一個WaitOrTimerCallback的代表,然后我們需要一個攜帶代表狀態(tài)的對象,同時我們也要決定休息間隔和執(zhí)行方式。我們將上面的都添加到線程池,并且激發(fā)一個事件:
public void afunction(object o)
{
// do what ever the function is supposed to do.
}
//object that will carry the status information
public class anObject
{
}
//thread entry code
{
//create an event object
ManualResetEvent aevent = new ManualResetEvent (false);
// create an instance of WaitOrTimerCallback
WaitOrTimerCallback thread_method = new WaitOrTimerCallback (afunction);
// create an instance of anObject
anObject myobj = new anObject();
// decide how thread will perform
int timeout_interval = 100; // timeout in milli-seconds.
bool onetime_exec = true;
//add all this to the thread pool.
ThreadPool. RegisterWaitForSingleObject (aevent, thread_method, myobj, timeout_interval, onetime_exec);
// raise the event
aevent.Set();
}
在QueueUserWorkItem和RegisterWaitForSingleObject方法中,線程池創(chuàng)建了一個后臺的線程來回調(diào)。當線程池開始執(zhí)行一個任務(wù),兩個方法都將調(diào)用者的堆棧合并到線程池的線程堆棧中。如果需要安全檢查將耗費更多的時間和增加系統(tǒng)的負擔,因此可以通過使用它們對應(yīng)的不安全的方法來避免安全檢查。就是ThreadPool.UnsafeRegisterWaitForSingleObject 和ThreadPool.UnsafeQueueUserWorkItem。
你也可以對與等待操作無關(guān)的任務(wù)排隊。 Timer-queue timers and registered wait operations也使用線程池。它們的返回方法也被放入線程池排隊。
線程池是非常有用的,被廣泛的用于。NET平臺上的套節(jié)子編程,等待操作注冊,進程計時器和異步的I/O。對于小而短的任務(wù),線程池提供的機制也是十分便利處于多線程的。線程池對于完成許多獨立的任務(wù)而且不需要逐個的設(shè)置線程屬性是十分便利的。但是,你也應(yīng)該很清楚,有很多的情況是可以用其他的方法來替代線程池的。比如說你的計劃任務(wù)或給每個線程特定的屬性,或者你需要將線程放入單個線程的空間(而線程池是將所有的線程放入一個多線程空間),抑或是一個特定的任務(wù)是很冗長的,這些情況你最好考慮清楚,安全的辦法比用線程池應(yīng)該是你的選擇。
System.Threading.Timer Class
Timer類對于周期性的在分離的線程執(zhí)行任務(wù)是非常有效的,它不能被繼承。
這個類尤其用來開發(fā)控制臺應(yīng)用程序,因為System.Windows.Forms.Time是不可用的。比如同來備份文件和檢查數(shù)據(jù)庫的一致性。
當創(chuàng)建Timer對象時,你藥估計在第一個代理調(diào)用之前等待的時間和后來的每次成功調(diào)用之間的時間。一個定時調(diào)用發(fā)生在方法的應(yīng)得時間過去,并且在后來周期性的調(diào)用這個方法。你可以適應(yīng)Timer的Change方法來改變這些設(shè)置的值或者使Timer失效。當定時器Timer不再使用時,你應(yīng)該調(diào)用Dispose方法來釋放其資源。
TimerCallback代表負責指定與Timer對象相關(guān)聯(lián)的方法(就是要周期執(zhí)行的任務(wù))和狀態(tài)。它在方法應(yīng)得的時間過去之后調(diào)用一次并且周期性的調(diào)用這個方法直到調(diào)用了Dispose方法釋放了Timer的所有資源。系統(tǒng)自動分配分離的線程。
讓我們來看一段代碼看看事如何創(chuàng)建Timer對象和使用它的。我們首先要創(chuàng)建一個TimerCallback代理,在后面的方法中要使用到的。如果需要,下一步我們要創(chuàng)建一個狀態(tài)對象,它擁有與被代理調(diào)用的方法相關(guān)聯(lián)的特定信息。為了使這些簡單一些,我們傳遞一個空參數(shù)。我們將實例化一個Timer對象,然后再使用Change方法改變Timer的設(shè)置,最后調(diào)用Dispose方法釋放資源。
// class that will be called by the Timer
public class WorkonTimerReq
{
public void aTimerCallMethod()
{
// does some work
}
}
//timer creation block
{
//instantiating the class that gets called by the Timer.
WorkonTimerReq anObj = new WorkonTimerReq () ;
// callback delegate
TimerCallback tcallback = new TimerCallback(anObj. aTimerCallMethod) ;
// define the dueTime and period
long dTime = 20 ; // wait before the first tick (in ms)
long pTime = 150 ; // timer during subsequent invocations (in ms)
// instantiate the Timer object
Timer atimer = new Timer(tcallback, null, dTime, pTime) ;
// do some thing with the timer object
...
//change the dueTime and period of the Timer
dTime=100;
pTime=300;
atimer.Change(dTime, pTime) ;
// do some thing
...
atimer.Dispose() ;
...
}
異步編程
這部分內(nèi)容如果要講清楚本來就是很大的一部分,在這里,我不打算詳細討論這個東西,我們只是需要直到它是什么,因為多線程編程如果忽律異步的多線程編程顯然是不應(yīng)該的。異步的多線程編程是你的程序可能會用到的另外一種多線程編程方法。
在前面的文章我們花了很大的篇幅來介紹線程的同步和怎么實現(xiàn)線程的同步,但是它有一個固有的致命的缺點,你或許注意到了這一點。那就是每個線程必須作同步調(diào)用,也就是等到其他的功能完成,否則就阻塞。當然,某些情況下,對于那些邏輯上相互依賴的任務(wù)來說是足夠的。異步編程允許更加復雜的靈活性。一個線程可以作異步調(diào)用,不需要等待其他的東西。你可以使用這些線程作任何的任務(wù),線程負責獲取結(jié)果推進運行。這給予了那些需要管理數(shù)目巨大的請求而且負擔不起請求等待代價的企業(yè)級的系統(tǒng)更好的可伸縮性。
.NET平臺提供了一致的異步編程機制用于ASP.NET,I/O,Web Services,Networking,Message等。
發(fā)表于 @ 2008年11月24日 22:47:00 | 評論( 0 ) | 舉報| 收藏
c#.net 多線程編程學習（3） 收藏 http://blog.csdn.net/coon32/archive/2008/11/24/3365045.aspx
Case 學習多線程
在前面的多線程編程系列的文章中，我們了解了在.NET中多線程編程必須要掌握的基本知識，但是可能大家看了文章之后，感覺還是很模糊，對一個具體的編程可能還是覺得無從下手，究其原因可能是理論講的過多，而沒有太多的實際參考例子，造成收獲不大。因此，在接下來的文章中，我將給出幾個典型的多線程編程的實例，讓大家有更清楚的認識。
Case 1 - No synchronization
在我們的第一個例子中，有兩類線程，兩個是讀線程，一個是寫線程，兩個線程是并行運行的并且需要訪問同一個共享資源。讀線程在寫線程之前啟動，用于設(shè)置共享變量的值。我使用Thread.Sleep來完成這些工作。摘錄代碼如下：
Thread t0 = new Thread(new ThreadStart(WriteThread));
Thread t1 = new Thread(new ThreadStart(ReadThread10));
Thread t2 = new Thread(new ThreadStart(ReadThread20));
t0.IsBackground=true;
t1.IsBackground=true;
t2.IsBackground=true;
t0.Start();
t1.Start();
t2.Start();
正如所看到的那樣，讀線程啟動之后立即啟動兩個寫線程。下面的代碼是兩個讀線程和寫線程所執(zhí)行的代碼。
public void WriteThread()
{
Thread.Sleep(1000);
m_x=3;
}
public void ReadThread10()
{
int a = 10;
for(int y=0;y<5;y++)
{
string s = "ReadThread10";
s = s + " # multiplier= ";
s = s + Convert.ToString(a) + " # ";
s = s + a * m_x;
listBox1.Items.Add(s);
Thread.Sleep(1000);
}
}
public void ReadThread20()
{
int a = 20;
for(int y=0;y<5;y++)
{
string s = "ReadThread20";
s = s + " # multiplier= ";
s = s + Convert.ToString(a) + " # ";
s = s + a * m_x;
listBox1.Items.Add(s);
Thread.Sleep(1000);
}
}
最后運行的結(jié)果如下：
通過上面的運行結(jié)果，我們可以明顯的看出運行結(jié)果并不是我們所期望的那樣，開始的兩個結(jié)果，讀線程運行在寫線程之前，這是我們極力要避免發(fā)生的事情。
下面我將使用ManualResetEvent來解決上面遇到的問題來達到線成的同步，唯一不同的是我們在啟動讀線程和寫線程之前使用安全的方法。
Thread t0 = new Thread(new ThreadStart(SafeWriteThread));
Thread t1 = new Thread(new ThreadStart(SafeReadThread10));
Thread t2 = new Thread(new ThreadStart(SafeReadThread20));
t0.IsBackground=true;
t1.IsBackground=true;
t2.IsBackground=true;
t0.Start();
t1.Start();
t2.Start();
添加一個ManualResetEvent：
m_mre = new ManualResetEvent(false);
看看SafeWriteThread的代碼：
public void SafeWriteThread()
{
m_mre.Reset();
WriteThread();
m_mre.Set();
}
Reset設(shè)置ManualResetEvent的狀態(tài)為non-signaled，這意味著事件沒有發(fā)生。接著我們來調(diào)用WriteThread方法，實際上可以跳過Reset這一步，因為我們在ManualResetEvent的構(gòu)造函數(shù)設(shè)置其狀態(tài)為non-signaled。一旦WriteThread線程返回，調(diào)用Set方法設(shè)置ManualResetEvent的狀態(tài)為signaled。
下面讓我們來看看另外兩個SafeReadThread方法：
public void SafeReadThread10()
{
m_mre.WaitOne();
ReadThread10();
}
public void SafeReadThread20()
{
m_mre.WaitOne();
ReadThread20();
}
WaitOne方法將阻塞當前的線程直到ManualResetEvent的狀態(tài)被設(shè)置為signaled。在這里，我們程序中的兩個讀線程都將阻塞至SafeWriteThread完成任務(wù)后調(diào)用Set方法。這樣我們就確保了兩個讀線程在寫線程完成對共享資源的訪問之后才執(zhí)行。
Case 3 - Synchronization [Many WriteThreads - Many ReadThreads]
下面我們將模擬更為復雜的情形。在下面的程序中，有多個寫線程和讀線程。讀線程只有在所有的寫線程完成了任務(wù)之后才能訪問共享資源。在實際的情況中，讀線程可能是并行的運行，但是為了簡便起見，我使寫線程運行有一定的順序，只有在前一個寫線程完成之后，第二個寫線程才能啟動。
在這里，我增加了一個ManualResetEvent對象和ManualResetEvent的數(shù)組。
public ManualResetEvent m_mreB;
public ManualResetEvent[] m_mre_array;
添加初始化代碼：
m_mreB = new ManualResetEvent(false);
m_mre_array = new ManualResetEvent[2];
m_mre_array[0]=m_mre;
m_mre_array[1]=m_mreB;
啟動四個線程：
Thread t0 = new Thread(new ThreadStart(SafeWriteThread));
Thread t0B = new Thread(new ThreadStart(SafeWriteThreadB));
Thread t1 = new Thread(new ThreadStart(SafeReadThread10B));
Thread t2 = new Thread(new ThreadStart(SafeReadThread20B));
t0.IsBackground=true;
t0B.IsBackground=true;
t1.IsBackground=true;
t2.IsBackground=true;
t0.Start();
t0B.Start();
t1.Start();
t2.Start();
在這里有兩個StartThreads和兩個WriteThreads，讓我們看看他們的執(zhí)行：
public void SafeWriteThread()
{
m_mre.Reset();
WriteThread();
m_mre.Set();
}
public void SafeWriteThreadB()
{
m_mreB.Reset();
m_mre.WaitOne();
Thread.Sleep(1000);
m_x+=3;
m_mreB.Set();
}
我對第二個WriteThread使用了另外一個事件對象，為了模擬等待第一個線程完成工作。
public void SafeReadThread10B()
{
WaitHandle.WaitAll(m_mre_array);
ReadThread10();
}
public void SafeReadThread20B()
{
WaitHandle.WaitAll(m_mre_array);
ReadThread20();
}
在這里，使用了一個WaitAll的方法，他是WaitHandle基類提供給ManualResetEvent的靜態(tài)方法，它的參數(shù)為我們在前面定義的ManualResetEvent數(shù)組。他阻塞當前的線程直到參數(shù)數(shù)組里面所有的ManualResetEvent對象設(shè)置狀態(tài)為signaled，換一句話說就是等待他們完成了各自的任務(wù)。
發(fā)表于 @ 2008年11月24日 22:50:00 | 評論( 1 ) | 舉報| 收藏
