多任務和多線程

?

在.NET多線程編程這個系列我們講一起來探討多線程編程的各個方面。首先我將在本篇文章的開始向大家介紹多線程的有關概念以及多線程編程的基礎知識;在接下來的文章中,我將逐一講述。NET平臺上多線程編程的知識,諸如System.Threading命名空間的重要類以及方法,并就一些例子程序來作說明。?

?

引言

?

早期的計算硬件十分復雜,但是操作系統執行的功能確十分的簡單。那個時候的操作系統在任一時間點只能執行一個任務,也就是同一時間只能執行一個程序。多個任務的執行必須得輪流執行,在系統里面進行排隊等候。由于計算機的發展,要求系統功能越來越強大，這個時候出現了分時操作的概念：每個運行的程序占有一定的處理機時間,當這個占有時間結束后,在等待隊列等待處理器資源的下一個程序就開始投入運行。注意這里的程序在占有一定的處理器時間后并沒有運行完畢，可能需要再一次或多次分配處理器時間。那么從這里可以看出，這樣的執行方式顯然是多個程序的并行執行，但是在宏觀上，我們感覺到多個任務是同時執行的，因此多任務的概念就誕生了。每個運行的程序都有自己的內存空間,自己的堆棧和環境變量設置。每一個程序對應一個進程，代表著執行一個大的任務。一個進程可以啟動另外一個進程,這個被啟動的進程稱為子進程。父進程和子進程的執行只有邏輯上的先后關系，并沒有其他的關系，也就是說他們的執行是獨立的。但是，可能一個大的程序（代表著一個大的任務）,可以分割成很多的小任務，為了功能上的需要也有可能是為了加快運行的速度，可能需要同一時間執行多個任務(每個任務分配一個多線程來執行相應的任務)。舉個例子來說,你正在通過你的web瀏覽器查看一些精彩的文章，你需要把好的文章給下載下來，可能有些非常精彩的文章你需要收藏起來，你就用你的打印機打印這些在線的文章。在這里，瀏覽器一邊下載HTML格式的文章，一邊還要打印文章。這就是一個程序同時執行多個任務，每個任務分配一個線程來完成。因此我們可以看出一個程序同時執行多個任務的能力是通過多線程來實現的。

?

多線程VS多任務

?

正如上面所說的,多任務是相對與操作系統而言,指的是同一時間執行多個程序的能力,雖然這么說,但是實際上在只有一個CPU的條件下不可能同時執行兩個以上的程序。CPU在程序之間做高速的切換,使得所有的程序在很短的時間之內可以得到更小的CPU時間,這樣從用戶的角度來看就好象是同時在執行多個程序。多線程相對于操作系統而言,指的是可以同時執行同一個程序的不同部分的能力,每個執行的部分被成為線程。所以在編寫應用程序時,我們必須得很好的設計以?避免不同的線程執行時的相互干擾。這樣有助于我們設計健壯的程序,使得我們可以在隨時需要的時候添加線程。

?

線程的概念

?

線程可以被描述為一個微進程,它擁有起點,執行的順序系列和一個終點。它負責維護自己的堆棧,這些堆棧用于異常處理,優先級調度和其他一些系統重新恢復線程執行時需要的信息。從這個概念看來，好像線程與進程沒有任何的區別，實際上線程與進程是肯定有區別的：

一個完整的進程擁有自己獨立的內存空間和數據,但是同一個進程內的線程是共享內存空間和數據的。一個進程對應著一段程序,它是由一些在同一個程序里面獨立的同時的運行的線程組成的。線程有時也被稱為并行運行在程序里的輕量級進程,線程被稱為是輕量級進程是因為它的運行依賴與進程提供的上下文環境,并且使用的是進程的資源。

在一個進程里,線程的調度有搶占式或者非搶占的模式。

在搶占模式下，操作系統負責分配ＣＰＵ時間給各個進程，一旦當前的進程使用完分配給自己的ＣＰＵ時間，操作系統將決定下一個占用ＣＰＵ時間的是哪一個線程。因此操作系統將定期的中斷當前正在執行的線程，將ＣＰＵ分配給在等待隊列的下一個線程。所以任何一個線程都不能獨占ＣＰＵ。每個線程占用ＣＰＵ的時間取決于進程和操作系統。進程分配給每個線程的時間很短,以至于我們感覺所有的線程是同時執行的。實際上,系統運行每個進程的時間有2毫秒,然后調度其他的線程。它同時他維持著所有的線程和循環,分配很少量的ＣＰＵ時間給線程。?線程的的切換和調度是如此之快,以至于感覺是所有的線程是同步執行的。

?

調度是什么意思?調度意味著處理器存儲著將要執行完ＣＰＵ時間的進程的狀態和將來某個時間裝載這個進程的狀態而恢復其運行。然而這種方式也有不足之處,一個線程可以在任何給定的時間中斷另外一個線程的執行。假設一個線程正在向一個文件做寫操作,而另外一個線程中斷其運行,也向同一個文件做寫操作。?Windows?95/NT,?UNIX使用的就是這種線程調度方式。

在非搶占的調度模式下,每個線程可以需要ＣＰＵ多少時間就占用ＣＰＵ多少時間。在這種調度方式下,可能一個執行時間很長的線程使得其他所有需要ＣＰＵ的線程”餓死”。在處理機空閑，即該進程沒有使用ＣＰＵ時，系統可以允許其他的進程暫時使用ＣＰＵ。占用ＣＰＵ的線程擁有對ＣＰＵ的控制權，只有它自己主動釋放ＣＰＵ時，其他的線程才可以使用ＣＰＵ。一些I/O和Windows?3。x就是使用這種調度策略。

在有些操作系統里面，這兩種調度策略都會用到。非搶占的調度策略在線程運行優先級一般時用到，而對于高優先級的線程調度則多采用搶占式的調度策略。如果你不確定系統采用的是那種調度策略，假設搶占的調度策略不可用是比較安全的。在設計應用程序的時候，我們認為那些占用ＣＰＵ時間比較多的線程在一定的間隔是會釋放ＣＰＵ的控制權的，這時候系統會查看那些在等待隊列里面的與當前運行的線程同一優先級或者更高的優先級的線程，而讓這些線程得以使用ＣＰＵ。如果系統找到一個這樣的線程，就立即暫停當前執行的線程和激活滿足條件的線程。如果沒有找到同一優先級或更高級的線程，當前線程還繼續占有ＣＰＵ。當正在執行的線程想釋放ＣＰＵ的控制權給一個低優先級的線程，當前線程就轉入睡眠狀態而讓低優先級的線程占有ＣＰＵ。

在多處理器系統，操作系統會將這些獨立的線程分配給不同的處理器執行，這樣將會大大的加快程序的運行。線程執行的效率也會得到很大的提高，因為將線程的分時共享單處理器變成了分布式的多處理器執行。這種多處理器在三維建模和圖形處理是非常有用的。

?

需要多線程嗎

?

我們發出了一個打印的命令，要求打印機進行打印任務，假設這時候計算機停止了響應而打印機還在工作，那豈不是我們的停止手上的事情就等著這慢速的打印機打印？所幸的是，這種情況不會發生，我們在打印機工作的時候還可以同時聽音樂或者畫圖。因為我們使用了獨立的多線程來執行這些任務。你可能會對多個用戶同時訪問數據庫或者web服務器感到吃驚，他們是怎么工作的？這是因為為每個連接到數據庫或者web服務器的用戶建立了獨立的線程來維護用戶的狀態。如果一個程序的運行有一定的順序，這時候采用這種方式可能會出現問題，甚至導致整個程序崩潰。如果程序可以分成獨立的不同的任務，使用多線程，即使某一部分任務失敗了，對其他的也沒有影響，不會導致整個程序崩潰。

?

毫無疑問的是，編寫多線程程序使得你有了一個利器可以駕奴非多線程的程序，但是多線程也可能成為一個負擔或者需要不小的代價。如果使用的不當，會帶來更多的壞處。如果一個程序有很多的線程，那么其他程序的線程必然只能占用更少的ＣＰＵ時間；而且大量的ＣＰＵ時間是用于線程調度的；操作系統也需要足夠的內存空間來維護每個線程的上下文信息；因此，大量的線程會降低系統的運行效率。因此，如果使用多線程的話，程序的多線程必須設計的很好，否則帶來的好處將遠小于壞處。因此使用多線程我們必須小心的處理這些線程的創建，調度和釋放工作。

?

多線程程序設計提示

?

有多種方法可以設計多線程的應用程序。正如后面的文章所示，我將給出詳細的編程示例，通過這些例子，你將可以更好的理解多線程。線程可以有不同的優先級，舉例子來說，在我們的應用程序里面，繪制圖形或者做大量運算的同時要接受用戶的輸入，顯然用戶的輸入需要得到第一時間的響應，而圖形繪制或者運算則需要大量的時間，暫停一下問題不大，因此用戶輸入線程將需要高的悠閑級，而圖形繪制或者運算低優先級即可。這些線程之間相互獨立，相互不影響。

在上面的例子中，圖形繪制或者大量的運算顯然是需要站用很多的ＣＰＵ時間的，在這段時間，用戶沒有必要等著他們執行完畢再輸入信息，因此我們將程序設計成獨立的兩個線程，一個負責用戶的輸入，一個負責處理那些耗時很長的任務。這將使得程序更加靈活，能夠快速響應。同時也可以使得用戶在運行的任何時候取消任務的可能。在這個繪制圖形的例子中，程序應該始終負責接收系統發來的消息。如果由于程序忙于一個任務，有可能會導致屏幕變成空白，這顯然需要我們的程序來處理這樣的事件。所以我必須得有一個線程負責來處理這些消息，正如剛才所說的應該觸發重畫屏幕的工作。

我們應該把握一個原則，對于那些對時間要求比較緊迫需要立即得到相應的任務，我們因該給予高的優先級，而其他的線程優先級應該低于她的優先級。偵聽客戶端請求的線程應該始終是高的優先級，對于一個與用戶交互的用戶界面的任務來說，它需要得到第一時間的響應，其優先級因該高優先級。

?

System.Threading.Thread類

在接下來的這篇文章中,我將向大家介紹.NET中的線程API,怎么樣用C#創建線程,啟動和停止線程,設置優先級和狀態.

在.NET中編寫的程序將被自動的分配一個線程.讓我們來看看用C#編程語言創建線程并且繼續學習線程的知識。我們都知道.NET的運行時環境的主線程由Main?()方法來啟動應用程序，而且.NET的編譯語言有自動的垃圾收集功能,這個垃圾收集發生在另外一個線程里面,所有的這些都是后臺發生的,讓我們無法感覺到發生了什么事情.在這里默認的是只有一個線程來完成所有的程序任務，但是正如我們在第一篇文章討論過的一樣，有可能我們根據需要自己添加更多的線程讓程序更好的協調工作。比如說我們的例子中，一個有用戶輸入的同時需要繪制圖形或者完成大量的運算的程序，我們必須得增加一個線程，讓用戶的輸入能夠得到及時的響應，因為輸入對時間和響應的要求是緊迫的，而另外一個線程負責圖形繪制或者大量的運算。

.NET?基礎類庫的System.Threading命名空間提供了大量的類和接口支持多線程。這個命名空間有很多的類，我們將在這里著重討論Thread這個類。

System.Threading.Thread類是創建并控制線程，設置其優先級并獲取其狀態最為常用的類。他有很多的方法，在這里我們將就比較常用和重要的方法做一下介紹：

Thread.Start（）：啟動線程的執行；

Thread.Suspend（）：掛起線程，或者如果線程已掛起，則不起作用；

Thread.Resume（）：繼續已掛起的線程；

Thread.Interrupt（）：中止處于?Wait或者Sleep或者Join?線程狀態的線程；

Thread.Join（）：阻塞調用線程，直到某個線程終止時為止

Thread.Sleep（）：將當前線程阻塞指定的毫秒數；

Thread.Abort（）：以開始終止此線程的過程。如果線程已經在終止，則不能通過Thread.Start（）來啟動線程。

通過調用Thread.Sleep，Thread.Suspend或者Thread.Join可以暫停/阻塞線程。調用Sleep()和Suspend()方法意味著線程將不再得到CPU時間。這兩種暫停線程的方法是有區別的，Sleep()使得線程立即停止執行，但是在調用Suspend()方法之前，公共語言運行時必須到達一個安全點。一個線程不能對另外一個線程調用Sleep()方法，但是可以調用Suspend()方法使得另外一個線程暫停執行。對已經掛起的線程調用Thread.Resume（）方法會使其繼續執行。不管使用多少次Suspend()方法來阻塞一個線程，只需一次調用Resume()方法就可以使得線程繼續執行。已經終止的和還沒有開始執行的線程都不能使用掛起。Thread.Sleep（int?x）使線程阻塞x毫秒。只有當該線程是被其他的線程通過調用Thread.Interrupt（）或者Thread.Abort（）方法，才能被喚醒。如果對處于阻塞狀態的線程調用Thread.Interrupt（）方法將使線程狀態改變，但是會拋出ThreadInterupptedException異常，你可以捕獲這個異常并且做出處理，也可以忽略這個異常而讓運行時終止線程。在一定的等待時間之內，Thread.Interrupt（）和Thread.Abort（）都可以立即喚醒一個線程。

下面我們將說明如何從一個線程中止另外一個線程。在這種情況下，我們可以通過使用Thread.Abort（）方法來永久銷毀一個線程，而且將拋出ThreadAbortException異常。使終結的線程可以捕獲到異常但是很難控制恢復，僅有的辦法是調用Thread.ResetAbort（）來取消剛才的調用，而且只有當這個異常是由于被調用線程引起的異常。因此，A線程可以正確的使用Thread.Abort（）方法作用于B線程，但是B線程卻不能調用Thread.ResetAbort（）來取消Thread.Abort（）操作。Thread.Abort（）方法使得系統悄悄的銷毀了線程而且不通知用戶。一旦實施Thread.Abort（）操作，該線程不能被重新啟動。調用了這個方法并不是意味著線程立即銷毀，因此為了確定線程是否被銷毀，我們可以調用Thread.Join（）來確定其銷毀，Thread.Join（）是一個阻塞調用，直到線程的確是終止了才返回。但是有可能一個線程調用Thread.Interrupt（）方法來中止另外一個線程，而這個線程正在等待Thread.Join（）調用的返回。

盡可能的不要用Suspend()方法來掛起阻塞線程，因為這樣很容易造成死鎖。假設你掛起了一個線程，而這個線程的資源是其他線程所需要的，會發生什么后果。因此，我們盡可能的給重要性不同的線程以不同的優先級，用Thread.Priority（）方法來代替使用Thread.Suspend（）方法。

Thread類有很多的屬性，這些重要的屬性是我們多線程編程必須得掌握的。

Thread.IsAlive屬性：獲取一個值，該值指示當前線程的執行狀態。如果此線程已啟動并且尚未正常終止或中止，則為?true；否則為?false。

Thread.Name?屬性：獲取或設置線程的名稱。

Thread.Priority?屬性：獲取或設置一個值，該值指示線程的調度優先級。
Thread.ThreadState?屬性：獲取一個值，該值包含當前線程的狀態。
在下面的例子中，我們將看看怎么設置這些屬性，在隨后的例子中我們將詳細的討論這些屬性。
創建一個線程，首先得實例化一個Thread類，在類得構造函數中調用ThreadStart委派。這個委派包含了線程從哪里開始執行。當線程啟動后，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
????????????????????}
}
}
在這個例子中，創建了一個fThread的線程對象，這個線程負責執行First_Thread()方法里面的任務。當Thread的Start()?方法被調用時包含First_Thread()的地址ThreadStart的代理將被執行。
Thread狀態
System.Threading.Thread.ThreadState屬性定義了執行時線程的狀態。線程從創建到線程終止，它一定處于其中某一個狀態。當線程被創建時，它處在Unstarted狀態，Thread類的Start()?方法將使線程狀態變為Running狀態，線程將一直處于這樣的狀態，除非我們調用了相應的方法使其掛起、阻塞、銷毀或者自然終止。如果線程被掛起，它將處于Suspended狀態，除非我們調用resume（）方法使其重新執行，這時候線程將重新變為Running狀態。一旦線程被銷毀或者終止，線程處于Stopped狀態。處于這個狀態的線程將不復存在，正如線程開始啟動，線程將不可能回到Unstarted狀態。線程還有一個Background狀態，它表明線程運行在前臺還是后臺。在一個確定的時間，線程可能處于多個狀態。據例子來說，一個線程被調用了Sleep而處于阻塞，而接著另外一個線程調用Abort方法于這個阻塞的線程，這時候線程將同時處于WaitSleepJoin和AbortRequested狀態。一旦線程響應轉為Sle阻塞或者中止，當銷毀時會拋出ThreadAbortException異常。
線程優先級
System.Threading.Thread.Priority枚舉了線程的優先級別，從而決定了線程能夠得到多少CPU時間。高優先級的線程通常會比一般優先級的線程得到更多的CPU時間，如果不止一個高優先級的線程，操作系統將在這些線程之間循環分配CPU時間。低優先級的線程得到的CPU時間相對較少，當這里沒有高優先級的線程，操作系統將挑選下一個低優先級?的線程執行。一旦低優先級的線程在執行時遇到了高優先級的線程，它將讓出CPU給高優先級的線程。新創建的線程優先級為一般優先級，我們可以設置線程的優先級別的值，如下面所示：
Highest?
AboveNormal?
Normal?
BelowNormal?
Lowest?
結論：在這一部分，我們討論了線程的創建何線程的優先級。System.Threading命名空間還包含了線程鎖定、線程同步何通訊、多線程管理類以及死鎖解決等等高級特性，在后面的部分我們將繼續討論這些內容。
線程同步

?

隨著對多線程學習的深入,你可能覺得需要了解一些有關線程共享資源的問題.?.NET?framework提供了很多的類和數據類型來控制對共享資源的訪問。

考慮一種我們經常遇到的情況：有一些全局變量和共享的類變量，我們需要從不同的線程來更新它們，可以通過使用System.Threading.Interlocked類完成這樣的任務，它提供了原子的，非模塊化的整數更新操作。

還有你可以使用System.Threading.Monitor類鎖定對象的方法的一段代碼，使其暫時不能被別的線程訪問。

System.Threading.WaitHandle類的實例可以用來封裝等待對共享資源的獨占訪問權的操作系統特定的對象。尤其對于非受管代碼的互操作問題。

System.Threading.Mutex用于對多個復雜的線程同步的問題，它也允許單線程的訪問。

像ManualResetEvent和AutoResetEvent這樣的同步事件類支持一個類通知其他事件的線程。

不討論線程的同步問題，等于對多線程編程知之甚少，但是我們要十分謹慎的使用多線程的同步。在使用線程同步時，我們事先就要要能夠正確的確定是那個對象和方法有可能造成死鎖（死鎖就是所有的線程都停止了相應，都在等者對方釋放資源）。還有贓數據的問題（指的是同一時間多個線程對數據作了操作而造成的不一致），這個不容易理解，這么說吧，有X和Y兩個線程，線程X從文件讀取數據并且寫數據到數據結構，線程Y從這個數據結構讀數據并將數據送到其他的計算機。假設在Y讀數據的同時，X寫入數據，那么顯然Y讀取的數據與實際存儲的數據是不一致的。這種情況顯然是我們應該避免發生的。少量的線程將使得剛才的問題發生的幾率要少的多，對共享資源的訪問也更好的同步。

.NET?Framework的CLR提供了三種方法來完成對共享資源?，諸如全局變量域，特定的代碼段，靜態的和實例化的方法和域。

（1）???????代碼域同步：使用Monitor類可以同步靜態/實例化的方法的全部代碼或者部分代碼段。不支持靜態域的同步。在實例化的方法中，this指針用于同步；而在靜態的方法中，類用于同步，這在后面會講到。

（2）???????手工同步：使用不同的同步類（諸如WaitHandle,?Mutex,?ReaderWriterLock,?ManualResetEvent,?AutoResetEvent?和Interlocked等）創建自己的同步機制。這種同步方式要求你自己手動的為不同的域和方法同步，這種同步方式也可以用于進程間的同步和對共享資源的等待而造成的死鎖解除。

（3）???????上下文同步：使用SynchronizationAttribute為ContextBoundObject對象創建簡單的，自動的同步。這種同步方式僅用于實例化的方法和域的同步。所有在同一個上下文域的對象共享同一個鎖。

?

Monitor?Class

?

在給定的時間和指定的代碼段只能被一個線程訪問，Monitor?類非常適合于這種情況的線程同步。這個類中的方法都是靜態的，所以不需要實例化這個類。下面一些靜態的方法提供了一種機制用來同步對象的訪問從而避免死鎖和維護數據的一致性。

Monitor.Enter?方法：在指定對象上獲取排他鎖。

Monitor.TryEnter?方法：試圖獲取指定對象的排他鎖。

Monitor.Exit?方法：釋放指定對象上的排他鎖。

Monitor.Wait?方法：釋放對象上的鎖并阻塞當前線程，直到它重新獲取該鎖。

Monitor.Pulse?方法：通知等待隊列中的線程鎖定對象狀態的更改。

Monitor.PulseAll?方法：通知所有的等待線程對象狀態的更改。

通過對指定對象的加鎖和解鎖可以同步代碼段的訪問。Monitor.Enter,?Monitor.TryEnter?和?Monitor.Exit用來對指定對象的加鎖和解鎖。一旦獲取（調用了Monitor.Enter）指定對象（代碼段）的鎖，其他的線程都不能獲取該鎖。舉個例子來說吧，線程X獲得了一個對象鎖，這個對象鎖可以釋放的（調用Monitor.Exit(object)?or?Monitor.Wait）。當這個對象鎖被釋放后，Monitor.Pulse方法和?Monitor.PulseAll方法通知就緒隊列的下一個線程進行和其他所有就緒隊列的線程將有機會獲取排他鎖。線程X釋放了鎖而線程Y獲得了鎖，同時調用Monitor.Wait的線程X進入等待隊列。當從當前鎖定對象的線程（線程Y）受到了Pulse或PulseAll，等待隊列的線程就進入就緒隊列。線程X重新得到對象鎖時，Monitor.Wait才返回。如果擁有鎖的線程（線程Y）不調用Pulse或PulseAll，方法可能被不確定的鎖定。Pulse,?PulseAll?and?Wait必須是被同步的代碼段鄂被調用。對每一個同步的對象，你需要有當前擁有鎖的線程的指針，就緒隊列和等待隊列（包含需要被通知鎖定對象的狀態變化的線程）的指針。

你也許會問，當兩個線程同時調用Monitor.Enter會發生什么事情？無論這兩個線程地調用Monitor.Enter是多么地接近，實際上肯定有一個在前，一個在后，因此永遠只會有一個獲得對象鎖。既然Monitor.Enter是原子操作，那么CPU是不可能偏好一個線程而不喜歡另外一個線程的。為了獲取更好的性能，你應該延遲后一個線程的獲取鎖調用和立即釋放前一個線程的對象鎖。對于private和internal的對象，加鎖是可行的，但是對于external對象有可能導致死鎖，因為不相關的代碼可能因為不同的目的而對同一個對象加鎖。

如果你要對一段代碼加鎖，最好的是在try語句里面加入設置鎖的語句，而將Monitor.Exit放在finally語句里面。對于整個代碼段的加鎖，你可以使用MethodImplAttribute（在System.Runtime.CompilerServices命名空間）類在其構造器中設置同步值。這是一種可以替代的方法，當加鎖的方法返回時，鎖也就被釋放了。如果需要要很快釋放鎖，你可以使用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);?

}?

上面的代碼運行會產生問題。當代碼運行到int?c=a/b;?的時候，會拋出一個異常，Monitor.Exit將不會返回。因此這段程序將掛起，其他的線程也將得不到鎖。有兩種方法可以解決上面的問題。第一個方法是：將代碼放入try…finally內，在finally調用Monitor.Exit，這樣的話最后一定會釋放鎖。第二種方法是：利用C#的lock（）方法。調用這個方法和調用Monitoy.Enter的作用效果是一樣的。但是這種方法一旦代碼執行超出范圍，釋放鎖將不會自動的發生。見下面的代碼:

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：通知一個或多個正在等待的線程已發生事件。無法繼承此類。

ManualResetEvent：當通知一個或多個正在等待的線程事件已發生時出現。無法繼承此類。

這些類定義了一些信號機制使得對資源排他性訪問的占有和釋放。他們有兩種狀態：signaled?和?nonsignaled。Signaled狀態的等待句柄不屬于任何線程，除非是nonsignaled狀態。擁有等待句柄的線程不再使用等待句柄時用set方法，其他的線程可以調用Reset方法來改變狀態或者任意一個WaitHandle方法要求擁有等待句柄，這些方法見下面：

WaitAll：等待指定數組中的所有元素收到信號。

WaitAny：等待指定數組中的任一元素收到信號。

WaitOne：當在派生類中重寫時，阻塞當前線程，直到當前的?WaitHandle?收到信號。

這些wait方法阻塞線程直到一個或者更多的同步對象收到信號。

WaitHandle對象封裝等待對共享資源的獨占訪問權的操作系統特定的對象無論是收管代碼還是非受管代碼都可以使用。但是它沒有Monitor使用輕便，Monitor是完全的受管代碼而且對操作系統資源的使用非常有效率。

?

Mutex?Class

?

Mutex是另外一種完成線程間和跨進程同步的方法，它同時也提供進程間的同步。它允許一個線程獨占共享資源的同時阻止其他線程和進程的訪問。Mutex的名字就很好的說明了它的所有者對資源的排他性的占有。一旦一個線程擁有了Mutex，想得到Mutex的其他線程都將掛起直到占有線程釋放它。Mutex.ReleaseMutex方法用于釋放Mutex，一個線程可以多次調用wait方法來請求同一個Mutex，但是在釋放Mutex的時候必須調用同樣次數的Mutex.ReleaseMutex。如果沒有線程占有Mutex，那么Mutex的狀態就變為signaled，否則為nosignaled。一旦Mutex的狀態變為signaled，等待隊列的下一個線程將會得到Mutex。Mutex類對應與win32的CreateMutex，創建Mutex對象的方法非常簡單，常用的有下面幾種方法：

一個線程可以通過調用WaitHandle.WaitOne?或?WaitHandle.WaitAny?或?WaitHandle.WaitAll得到Mutex的擁有權。如果Mutex不屬于任何線程，上述調用將使得線程擁有Mutex，而且WaitOne會立即返回。但是如果有其他的線程擁有Mutex，WaitOne將陷入無限期的等待直到獲取Mutex。你可以在WaitOne方法中指定參數即等待的時間而避免無限期的等待Mutex。調用Close作用于Mutex將釋放擁有。一旦Mutex被創建，你可以通過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();?

}?

在上面的例子中，線程創建了Mutex，但是開始并沒有申明擁有它，通過調用WaitOne方法擁有Mutex。

?

Synchronization?Events

?

同步時間是一些等待句柄用來通知其他的線程發生了什么事情和資源是可用的。他們有兩個狀態：signaled?and?nonsignaled。AutoResetEvent?和?ManualResetEvent就是這種同步事件。

?

AutoResetEvent?Class

?

這個類可以通知一個或多個線程發生事件。當一個等待線程得到釋放時，它將狀態轉換為signaled。用set方法使它的實例狀態變為signaled。但是一旦等待的線程被通知時間變為signaled，它的轉臺將自動的變為nonsignaled。如果沒有線程偵聽事件，轉臺將保持為signaled。此類不能被繼承。

?

ManualResetEvent?Class

?

這個類也用來通知一個或多個線程事件發生了。它的狀態可以手動的被設置和重置。手動重置時間將保持signaled狀態直到ManualResetEvent.Reset設置其狀態為nonsignaled，或保持狀態為nonsignaled直到ManualResetEvent.Set設置其狀態為signaled。這個類不能被繼承。

?

Interlocked?Class

?

它提供了在線程之間共享的變量訪問的同步，它的操作時原子操作，且被線程共享.你可以通過Interlocked.Increment?或?Interlocked.Decrement來增加或減少共享變量.它的有點在于是原子操作,也就是說這些方法可以代一個整型的參數增量并且返回新的值,所有的操作就是一步.你也可以使用它來指定變量的值或者檢查兩個變量是否相等,如果相等,將用指定的值代替其中一個變量的值.

?

ReaderWriterLock?class

?

它定義了一種鎖,提供唯一寫/多讀的機制,使得讀寫的同步.任意數目的線程都可以讀數據,數據鎖在有線程更新數據時將是需要的.讀的線程可以獲取鎖,當且僅當這里沒有寫的線程.當沒有讀線程和其他的寫線程時,寫線程可以得到鎖.因此,一旦writer-lock被請求,所有的讀線程將不能讀取數據直到寫線程訪問完畢.它支持暫停而避免死鎖.它也支持嵌套的讀/寫鎖.支持嵌套的讀鎖的方法是ReaderWriterLock.AcquireReaderLock,如果一個線程有寫鎖則該線程將暫停;

支持嵌套的寫鎖的方法是ReaderWriterLock.AcquireWriterLock,如果一個線程有讀鎖則該線程暫停.如果有讀鎖將容易倒是死鎖.安全的辦法是使用ReaderWriterLock.UpgradeToWriterLock方法,這將使讀者升級到寫者.你可以用ReaderWriterLock.DowngradeFromWriterLock方法使寫者降級為讀者.調用ReaderWriterLock.ReleaseLock將釋放鎖,?ReaderWriterLock.RestoreLock將重新裝載鎖的狀態到調用ReaderWriterLock.ReleaseLock以前.

?

結論:

?

這部分講述了.NET平臺上的線程同步的問題.造接下來的系列文章中我將給出一些例子來更進一步的說明這些使用的方法和技巧.雖然線程同步的使用會給我們的程序帶來很大的價值,但是我們最好能夠小心使用這些方法.否則帶來的不是受益,而將倒是性能下降甚至程序崩潰.只有大量的聯系和體會才能使你駕馭這些技巧.盡量少使用那些在同步代碼塊完成不了或者不確定的阻塞的東西,尤其是I/O操作;盡可能的使用局部變量來代替全局變量;同步用在那些部分代碼被多個線程和進程訪問和狀態被不同的進程共享的地方;安排你的代碼使得每一個數據在一個線程里得到精確的控制;不是共享在線程之間的代碼是安全的;在下一篇文章中我們將學習線程池有關的知識.

線程池和異步編程

?

如果你仔細閱讀了我前面的三篇文章,我相信你對用.NET?Framework提供的System.Threading.Thread類和一些線程同步的類基本的線程知識和多線程編程知識很了解。我們將在這里進一步討論一些.NET類,以及他們在多線程編程中扮演的角色和怎么編程。它們是:

System.Threading.ThreadPool?類

System.Threading.Timer?類

如果線程的數目并不是很多,而且你想控制每個線程的細節諸如線程的優先級等,使用Thread是比較合適的;但是如果有大量的線程,考慮使用線程池應該更好一些,它提供了高效的線程管理機制來處理多任務。?對于定期的執行任務Timer類是合適的;使用代表是異步方法調用的首選。

?

System.Threading.ThreadPool?Class

?

當你創建應用程序時,你應該認識到大部分時間你的線程在空閑的等待某些事件的發生(諸如按下一個鍵或偵聽套節子的請求)。毫無疑問的,你也會認為這是絕對的浪費資源。

如果這里有很多的任務需要完成,每個任務需要一個線程,你應該考慮使用線程池來更有效的管理你的資源并且從中受益。線程池是執行的多個線程集合,它允許你添加以線程自動創建和開始的任務到隊列里面去。使用線程池使得你的系統可以優化線程在CPU使用時的時間碎片。但是要記住在任何特定的時間點,每一個進程和每個線程池只有一個一個正在運行的線程。這個類使得你的線程組成的池可以被系統管理,而使你的主要精力集中在工作流的邏輯而不是線程的管理。

當第一次實例化ThreadPool類時線程池將被創建。它有一個默認的上限,即每處理器最多可以有25個,但是這個上限是可以改變的。這樣使得處理器不會閑置下來。如果其中一個線程等待某個事件的發生,線程池將初始化另外一個線程并投入處理器工作,線程池就是這樣不停的創建工作的線程和分配任務給那些沒有工作的在隊列里的線程。唯一的限制是工作線程的數目不能超過最大允許的數目。每個線程將運行在默認的優先級和使用默認的屬于多線程空間的堆棧大小空間。一旦一項工作任務被加入隊列,你是不能取消的。

請求線程池處理一個任務或者工作項可以調用QueueUserWorkItem方法。這個方法帶一個WaitCallback代表類型的參數,這個參數包裝了你藥完成的任務。運行時自動為每一個的任務創建線程并且在任務釋放時釋放線程。

下面的代碼說明了如何創建線程池和怎樣添加任務:

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);?

}?

?

你也可以通過調用ThreadPool.RegisterWaitForSingleObject方法來傳遞一個System.Threading.WaitHandle,當被通知或者時間超過了調用被System.Threading.WaitOrTimerCallback包裝的方法。

?

線程池和基于事件的編程模式使得線程池對注冊的WaitHandles的監控和對合適的WaitOrTimerCallback代表方法的調用十分簡單(當WaitHandle被釋放時)。這些做法其實很簡單。這里有一個線程不斷的觀測在線程池隊列等待操作的狀態。一旦等待操作完成,一個線程將被執行與其對應的任務。因此,這個方法隨著出發觸發事件的發生而增加一個線程。

讓我們看看怎么隨事件添加一個線程到線程池,其實很簡單。我們只需要創建一個ManualResetEvent類的事件和一個WaitOrTimerCallback的代表,然后我們需要一個攜帶代表狀態的對象,同時我們也要決定休息間隔和執行方式。我們將上面的都添加到線程池,并且激發一個事件:

public?void?afunction(object?o)?

{?

???//?do?what?ever?the?function?is?supposed?to?do.?

}?

??

//object?that?will?carry?the?status?info?O:P>?

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方法中,線程池創建了一個后臺的線程來回調。當線程池開始執行一個任務,兩個方法都將調用者的堆棧合并到線程池的線程堆棧中。如果需要安全檢查將耗費更多的時間和增加系統的負擔,因此可以通過使用它們對應的不安全的方法來避免安全檢查。就是ThreadPool.UnsafeRegisterWaitForSingleObject?和ThreadPool.UnsafeQueueUserWorkItem。

你也可以對與等待操作無關的任務排隊。?Timer-queue?timers?and?registered?wait?operations也使用線程池。它們的返回方法也被放入線程池排隊。

線程池是非常有用的,被廣泛的用于。NET平臺上的套節子編程,等待操作注冊,進程計時器和異步的I/O。對于小而短的任務,線程池提供的機制也是十分便利處于多線程的。線程池對于完成許多獨立的任務而且不需要逐個的設置線程屬性是十分便利的。但是,你也應該很清楚,有很多的情況是可以用其他的方法來替代線程池的。比如說你的計劃任務或給每個線程特定的屬性,或者你需要將線程放入單個線程的空間(而線程池是將所有的線程放入一個多線程空間),抑或是一個特定的任務是很冗長的,這些情況你最好考慮清楚,安全的辦法比用線程池應該是你的選擇。

?

System.Threading.Timer?Class

?

Timer類對于周期性的在分離的線程執行任務是非常有效的,它不能被繼承。

這個類尤其用來開發控制臺應用程序,因為System.Windows.Forms.Time是不可用的。比如同來備份文件和檢查數據庫的一致性。

當創建Timer對象時,你藥估計在第一個代理調用之前等待的時間和后來的每次成功調用之間的時間。一個定時調用發生在方法的應得時間過去,并且在后來周期性的調用這個方法。你可以適應Timer的Change方法來改變這些設置的值或者使Timer失效。當定時器Timer不再使用時,你應該調用Dispose方法來釋放其資源。

TimerCallback代表負責指定與Timer對象相關聯的方法(就是要周期執行的任務)和狀態。它在方法應得的時間過去之后調用一次并且周期性的調用這個方法直到調用了Dispose方法釋放了Timer的所有資源。系統自動分配分離的線程。

讓我們來看一段代碼看看事如何創建Timer對象和使用它的。我們首先要創建一個TimerCallback代理,在后面的方法中要使用到的。如果需要,下一步我們要創建一個狀態對象,它擁有與被代理調用的方法相關聯的特定信息。為了使這些簡單一些,我們傳遞一個空參數。我們將實例化一個Timer對象,然后再使用Change方法改變Timer的設置,最后調用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()?;???????

?????

}

?

異步編程

?

這部分內容如果要講清楚本來就是很大的一部分,在這里,我不打算詳細討論這個東西,我們只是需要直到它是什么,因為多線程編程如果忽律異步的多線程編程顯然是不應該的。異步的多線程編程是你的程序可能會用到的另外一種多線程編程方法。

在前面的文章我們花了很大的篇幅來介紹線程的同步和怎么實現線程的同步,但是它有一個固有的致命的缺點,你或許注意到了這一點。那就是每個線程必須作同步調用,也就是等到其他的功能完成,否則就阻塞。當然,某些情況下,對于那些邏輯上相互依賴的任務來說是足夠的。異步編程允許更加復雜的靈活性。一個線程可以作異步調用,不需要等待其他的東西。你可以使用這些線程作任何的任務,線程負責獲取結果推進運行。這給予了那些需要管理數目巨大的請求而且負擔不起請求等待代價的企業級的系統更好的可伸縮性。

.NET平臺提供了一致的異步編程機制用于ASP.NET,I/O,Web?Services,Networking,Message等。

?

后記

由于學習的時候很難找到中文這方面的資料，因此我就只好學習英文的資料，由于水平不高，翻譯的時候可能難免曲解原文的意思，希望大家能夠指出，同時希望這些東西能夠給大家在學習這方面知識給予一定的參考和幫助，那怕是一點點，就很欣慰了。

?
Case?學習多線程

?

在前面的多線程編程系列的文章中，我們了解了在.NET中多線程編程必須要掌握的基本知識，但是可能大家看了文章之后，感覺還是很模糊，對一個具體的編程可能還是覺得無從下手，究其原因可能是理論講的過多，而沒有太多的實際參考例子，造成收獲不大。因此，在接下來的文章中，我將給出幾個典型的多線程編程的實例，讓大家有更清楚的認識。

?

Case?1?-?No?synchronization

在我們的第一個例子中，有兩類線程，兩個是讀線程，一個是寫線程，兩個線程是并行運行的并且需要訪問同一個共享資源。讀線程在寫線程之前啟動，用于設置共享變量的值。我使用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();

?

正如所看到的那樣，讀線程啟動之后立即啟動兩個寫線程。下面的代碼是兩個讀線程和寫線程所執行的代碼。

?

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);
????????}
}
最后運行的結果如下：


?

通過上面的運行結果，我們可以明顯的看出運行結果并不是我們所期望的那樣，開始的兩個結果，讀線程運行在寫線程之前，這是我們極力要避免發生的事情。

Case?2?-?Synchronization?[One?WriteThread?-?Many?ReadThreads]
下面我將使用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設置ManualResetEvent的狀態為non-signaled，這意味著事件沒有發生。接著我們來調用WriteThread方法，實際上可以跳過Reset這一步，因為我們在ManualResetEvent的構造函數設置其狀態為non-signaled。一旦WriteThread線程返回，調用Set方法設置ManualResetEvent的狀態為signaled。

下面讓我們來看看另外兩個SafeReadThread方法：

public?void?SafeReadThread10()
{
????????m_mre.WaitOne();
????????ReadThread10();
}
public?void?SafeReadThread20()
{
????????m_mre.WaitOne();
????????ReadThread20();
}
?

WaitOne方法將阻塞當前的線程直到ManualResetEvent的狀態被設置為signaled。在這里，我們程序中的兩個讀線程都將阻塞至SafeWriteThread完成任務后調用Set方法。這樣我們就確保了兩個讀線程在寫線程完成對共享資源的訪問之后才執行。下面是運行的結果：


?

?

Case?3?-?Synchronization?[Many?WriteThreads?-?Many?ReadThreads]

?

下面我們將模擬更為復雜的情形。在下面的程序中，有多個寫線程和讀線程。讀線程只有在所有的寫線程完成了任務之后才能訪問共享資源。在實際的情況中，讀線程可能是并行的運行，但是為了簡便起見，我使寫線程運行有一定的順序，只有在前一個寫線程完成之后，第二個寫線程才能啟動。

在這里，我增加了一個ManualResetEvent對象和ManualResetEvent的數組。

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，讓我們看看他們的執行：

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的靜態方法，它的參數為我們在前面定義的ManualResetEvent數組。他阻塞當前的線程直到參數數組里面所有的ManualResetEvent對象設置狀態為signaled，換一句話說就是等待他們完成了各自的任務。

?

轉載于:https://www.cnblogs.com/hq2008/archive/2007/07/24/829918.html

總結

以上是生活随笔為你收集整理的Thread concepts的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。