C#中的多線程

來源:互聯網
上載者:User
C#中的多線程

一.多線程的概念 

Windows是一個多任務的系統,如果你使用的是windows 2000及其以上版本,你可以通過工作管理員查看當前系統啟動並執行程式和進程。什麼是進程呢?當一個程式開始運行時,它就是一個進程,進程所指包括運行中的程式和程式所使用到的記憶體和系統資源。而一個進程又是由多個線程所組成的,線程是程式中的一個執行流,每個線程都有自己的專有寄存器(棧指標、程式計數器等),但代碼區是共用的,即不同的線程可以執行同樣的函數。多線程是指程式中包含多個執行流,即在一個程式中可以同時運行多個不同的線程來執行不同的任務,也就是說允許單個程式建立多個並存執行的線程來完成各自的任務。瀏覽器就是一個很好的多線程的例子,在瀏覽器中你可以在下載JAVA小應用程式或圖象的同時滾動頁面,在訪問新頁面時,播放動畫和聲音,列印檔案等。 

多線程的好處在於可以提高CPU的利用率——任何一個程式員都不希望自己的程式很多時候沒事可幹,在多線程程式中,一個線程必須等待的時候,CPU可以運行其它的線程而不是等待,這樣就大大提高了程式的效率。 

然而我們也必須認識到線程本身可能影響系統效能的不利方面,以正確使用線程: 

線程也是程式,所以線程需要佔用記憶體,線程越多佔用記憶體也越多 
多線程需要協調和管理,所以需要CPU時間跟蹤線程 
線程之間對共用資源的訪問會相互影響,必須解決競用共用資源的問題 
線程太多會導致控制太複雜,最終可能造成很多Bug 

基於以上認識,我們可以一個比喻來加深理解。假設有一個公司,公司裡有很多各司其職的職員,那麼我們可以認為這個正常運作的公司就是一個進程,而公司裡的職員就是線程。一個公司至少得有一個職員吧,同理,一個進程至少包含一個線程。在公司裡,你可以一個職員幹所有的事,但是效率很顯然是高不起來的,一個人的公司也不可能做大;一個程式中也可以只用一個線程去做事,事實上,一些過時的語言如fortune,basic都是如此,但是象一個人的公司一樣,效率很低,如果做大程式,效率更低——事實上現在幾乎沒有單線程的商業軟體。公司的職員越多,老闆就得發越多的薪水給他們,還得耗費大量精力去管理他們,協調他們之間的矛盾和利益;程式也是如此,線程越多耗費的資源也越多,需要CPU時間去跟蹤線程,還得解決諸如死結,同步等問題。總之,如果你不想你的公司被稱為“皮包公司”,你就得多幾個員工;如果你不想讓你的程式顯得稚氣,就在你的程式裡引入多線程吧! 

本文將對C#編程中的多線程機制進行探討,通過一些執行個體解決對線程的控制,多線程間通訊等問題。為了省去建立GUI那些繁瑣的步驟,更清晰地逼近線程的本質,下面所有的程式都是控制台程式,程式最後的Console.ReadLine()是為了使程式中途停下來,以便看清楚執行過程中的輸出。 

好了,廢話少說,讓我們來體驗一下多線程的C#吧! 
二.操縱一個線程

任何程式在執行時,至少有一個主線程,下面這段小程式可以給讀者一個直觀的印象:

[CODE] 
//SystemThread.cs 
using System; 
using System.Threading; 

namespace ThreadTest 

  class RunIt 
  { 
    [STAThread] 
    static void Main(string[] args) 
    { 
      Thread.CurrentThread.Name="System Thread";//給當前線程起名為"System Thread" 
Console.WriteLine(Thread.CurrentThread.Name+"'Status:"+Thread.CurrentThread.ThreadState); 
      Console.ReadLine(); 
    } 
  } 

[/CODE] 

編譯執行後你看到了什嗎?是的,程式將產生如下輸出: 

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()方法掛起的線程的執行 
下面我們就動手來建立一個線程,使用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(); 
        //這裡建立一個線程,使之執行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。給一個線程指定優先順序 
,我們可以使用如下代碼: 

//設定優先順序為最低 
myThread.Priority=ThreadPriority.Lowest; 

通過設定線程的優先順序,我們可以安排一些相對重要的線程優先執行,例如對使用者的響應等等。 

現在我們對怎樣建立和控制一個線程已經有了一個初步的瞭解,下面我們將深入研究線程實現中比較典型的的問題,並且探討其解決方案。 

三.線程的同步和通訊——生產者和消費者 

假設這樣一種情況,兩個線程同時維護一個隊列,如果一個線程對隊列中添加元素,而另外一個線程從隊列中取用元素,那麼我們稱添加元素的線程為生產者,稱取用元素的線程為消費者。生產者與消費者問題看起來很簡單,但是卻是多線程應用中一個必須解決的問題,它涉及到線程之間的同步和通訊問題。 

前面說過,每個線程都有自己的資源,但是代碼區是共用的,即每個線程都可以執行相同的函數。但是多線程環境下,可能帶來的問題就是幾個線程同時執行一個函數,導致資料的混亂,產生不可預料的結果,因此我們必須避免這種情況的發生。C#提供了一個關鍵字lock,它可以把一段代碼定義為互斥段(critical section),互斥段在一個時刻內只允許一個線程進入執行,而其他線程必須等待。在C#中,關鍵字lock定義如下: 

lock(expression) statement_block 
expression代表你希望跟蹤的對象,通常是對象引用。一般地,如果你想保護一個類的執行個體,你可以使用this;如果你希望保護一個靜態變數(如互斥程式碼片段在一個靜態方法內部),一般使用類名就可以了。而statement_block就是互斥段的代碼,這段代碼在一個時刻內只可能被一個線程執行。 

  下面是一個使用lock關鍵字的典型例子,我將在注釋裡向大家說明lock關鍵字的用法和用途: 

//lock.cs 
using System; 
using System.Threading; 

internal class Account 

int balance; 
Random r = new Random(); 
internal Account(int initial) 

balance = initial; 

internal int Withdraw(int amount) 

if (balance < 0) 

//如果balance小於0則拋出異常 
throw new Exception("Negative Balance"); 

//下面的代碼保證在當前線程修改balance的值完成之前 
//不會有其他線程也執行這段代碼來修改balance的值 
//因此,balance的值是不可能小於0的 
lock (this) 

Console.WriteLine("Current Thread:"+Thread.CurrentThread.Name); 
//如果沒有lock關鍵字的保護,那麼可能在執行完if的條件判斷之後 
//另外一個線程卻執行了balance=balance-amount修改了balance的值 
//而這個修改對這個線程是不可見的,所以可能導致這時if的條件已經不成立了 
//但是,這個線程卻繼續執行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.Exit(oQueue);//釋放鎖 

如上所示,當一個線程調用Monitor.Enter()方法鎖定一個對象時,這個對象就歸它所有了,其它線程想要訪問這個對象,只有等待它使用Monitor.Exit()方法釋放鎖。為了保證線程最終都能釋放鎖,你可以把Monitor.Exit()方法寫在try-catch-finally結構中的finally代碼塊裡。對於任何一個被Monitor鎖定的對象,記憶體中都儲存著與它相關的一些資訊,其一是現在持有鎖的線程的引用,其二是一個預備隊列,隊列中儲存了已經準備好擷取鎖的線程,其三是一個等待隊列,隊列中儲存著當前正在等待這個對象狀態改變的隊列的引用。當擁有對象鎖的線程準備釋放鎖時,它使用Monitor.Pulse()方法通知等待隊列中的第一個線程,於是該線程被轉移到預備隊列中,當對象鎖被釋放時,在預備隊列中的線程可以立即獲得對象鎖。 

下面是一個展示如何使用lock關鍵字和Monitor類來實現線程的同步和通訊的例子,也是一個典型的生產者與消費者問題。這個常式中,生產者線程和消費者線程是交替進行的,生產者寫入一個數,消費者立即讀取並且顯示,我將在注釋中介紹該程式的精要所在。用到的系統命名空間如下: 

using System; 
using System.Threading; 

引自:http://www.daima.com.cn/info/234.htm ,在此感謝原作者

相關文章

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.