發新話題

[分享] 淺析.Net下的多線程編程

淺析.Net下的多線程編程

淺析.Net下的多線程編程

多線程是許多操作系統所具有的特性,它能大大提高程序的運行效率,所以多線程編程技術為編程者廣泛關注。目前微軟的.Net戰略正進一步推進,各種相關的技術正為廣大編程者所接受,同樣在.Net中多線程編程技術具有相當重要的地位。本文我就向大家介紹在.Net下進行多線程編程的基本方法和步驟。
   
   
   
  開始新線程
   
  在.Net下創建一個新線程是非常容易的,你可以通過以下的語句來開始一個新的線程:
   
   
  Thread thread = new Thread (new ThreadStart (ThreadFunc));
   
  thread.Start ();
   
   
   
  第一條語句創建一個新的Thread對象,並指明了一個該線程的方法。當新的線程開始時,該方法也就被調用執行了。該線程對像通過一個System..Threading.ThreadStart類的一個實例以類型安全的方法來調用它要調用的線程方法。
   
   
  第二條語句正式開始該新線程,一旦方法Start()被調用,該線程就保持在一個"alive"的狀態下了,你可以通過讀取它的IsAlive屬性來判斷它是否處於"alive"狀態。下面的語句顯示了如果一個線程處於"alive"狀態下就將該線程掛起的方法:
   
   
  if (thread.IsAlive) {
   
  thread.Suspend ();
   
  }
   
   
   
  不過請注意,線程對象的Start()方法只是啟動了該線程,而並不保證其線程方法ThreadFunc()能立即得到執行。它只是保證該線程對像能被分配到CPU時間,而實際的執行還要由操作系統根據處理器時間來決定。
   
   
  一個線程的方法不包含任何參數,同時也不返回任何值。它的命名規則和一般函數的命名規則相同。它既可以是靜態的(static)也可以是非靜態的(nonstatic)。當它執行完畢後,相應的線程也就結束了,其線程對象的IsAlive屬性也就被置為false了。下面是一個線程方法的實例:
   
   
  public static void ThreadFunc()
   
  {
   
  for (int i = 0; i <10; i++) {
   
  Console.WriteLine("ThreadFunc {0}", i);
   
  }
   
  }
   
   
   
   
  前台線程和後台線程
   
  .Net的公用語言運行時(Common Language Runtime,CLR)能區分兩種不同類型的線程:前台線程和後台線程。這兩者的區別就是:應用程序必須運行完所有的前台線程才可以退出;而對於後台線程,應用程序則可以不考慮其是否已經運行完畢而直接退出,所有的後台線程在應用程序退出時都會自動結束。
   
   
  一個線程是前台線程還是後台線程可由它的IsBackground屬性來決定。這個屬性是可讀又可寫的。它的默認值為false,即意味著一個線程默認為前台線程。我們可以將它的IsBackground屬性設置為true,從而使之成為一個後台線程。
   
   
  下面的例子是一個控制台程序,程序一開始便啟動了10個線程,每個線程運行5秒鐘時間。由於線程的IsBackground屬性默認為false,即它們都是前台線程,所以儘管程序的主線程很快就運行結束了,但程序要到所有已啟動的線程都運行完畢才會結束。示例代碼如下:
   
   
  using System;
   
  using System.Threading;
   
  class MyApp
   
  {
   
  public static void Main ()
   
  {
   
  for (int i=0; i<10; i++) {
   
  Thread thread = new Thread (new ThreadStart (ThreadFunc));
   
  thread.Start ();
   
  }
   
  }
   
  private static void ThreadFunc ()
   
  {
   
  DateTime start = DateTime.Now;
   
  while ((DateTime.Now - start).Seconds <5)
   
  ;
   
  }
   
  }
   
   
   
  接下來我們對上面的代碼進行略微修改,將每個線程的IsBackground屬性都設置為true,則每個線程都是後台線程了。那麼只要程序的主線程結束了,整個程序也就結束了。示例代碼如下:
   
   
  using System;
   
  using System.Threading;
   
  class MyApp
   
  {
   
  public static void Main ()
   
  {
   
  for (int i=0; i<10; i++) {
   
  Thread thread = new Thread (new ThreadStart (ThreadFunc));
   
  thread.IsBackground = true;
   
  thread.Start ();
   
  }
   
  }
   
  private static void ThreadFunc ()
   
  {
   
  DateTime start = DateTime.Now;
   
  while ((DateTime.Now - start).Seconds <5)
   
  ;
   
  }
   
  }
   
   
   
  既然前台線程和後台線程有這種差別,那麼我們怎麼知道該如何設置一個線程的IsBackground屬性呢?下面是一些基本的原則:對於一些在後台運行的線程,當程序結束時這些線程沒有必要繼續運行了,那麼這些線程就應該設置為後台線程。比如一個程序啟動了一個進行大量運算的線程,可是只要程序一旦結束,那個線程就失去了繼續存在的意義,那麼那個線程就該是作為後台線程的。而對於一些服務於用戶界面的線程往往是要設置為前台線程的,因為即使程序的主線程結束了,其他的用戶界面的線程很可能要繼續存在來顯示相關的信息,所以不能立即終止它們。這裡我只是給出了一些原則,具體到實際的運用往往需要編程者的進一步仔細斟酌。
   
   
  線程優先級
   
  一旦一個線程開始運行,線程調度程序就可以控制其所獲得的CPU時間。如果一個托管的應用程序運行在Windows機器上,則線程調度程序是由Windows所提供的。在其他的平台上,線程調度程序可能是操作系統的一部分,也自然可能是.Net框架的一部分。不過我們這裡不必考慮線程的調度程序是如何產生的,我們只要知道通過設置線程的優先級我們就可以使該線程獲得不同的CPU時間。
   
   
  線程的優先級是由Thread.Priority屬性控制的,其值包含:ThreadPriority.Highest、ThreadPriority.AboveNormal、ThreadPriority.Normal、ThreadPriority.BelowNormal和ThreadPriority.Lowest。從它們的名稱上我們自然可以知道它們的優先程度,所以這裡就不多作介紹了。
   
   
  線程的默認優先級為ThreadPriority.Normal。理論上,具有相同優先級的線程會獲得相同的CPU時間,不過在實際執行時,消息隊列中的線程阻塞或是操作系統的優先級的提高等原因會導致具有相同優先級的線程會獲得不同的CPU時間。不過從總體上來考慮仍可以忽略這種差異。你可以通過以下的方法來改變一個線程的優先級。
   
   
  thread.Priority = ThreadPriority.AboveNormal;
   
  或是:

  thread.Priority = ThreadPriority.BelowNormal;
   
   
   
  通過上面的第一句語句你可以提高一個線程的優先級,那麼該線程就會相應的獲得更多的CPU時間;通過第二句語句你便降低了那個線程的優先級,於是它就會被分配到比原來少的CPU時間了。你可以在一個線程開始運行前或是在它的運行過程中的任何時候改變它的優先級。理論上你還可以任意的設置每個線程的優先級,不過一個優先級過高的線程往往會影響到其他線程的運行,甚至影響到其他程序的運行,所以最好不要隨意的設置線程的優先級。
   
   
   
  掛起線程和重新開始線程
   
  Thread類分別提供了兩個方法來掛起線程和重新開始線程,也就是Thread.Suspend能暫停一個正在運行的線程,而Thread.Resume又能讓那個線程繼續運行。不像Windows內核,.Net框架是不記錄線程的掛起次數的,所以不管你掛起線程過幾次,只要一次調用Thread.Resume就可以讓掛起的線程重新開始運行。
   
   
  Thread類還提供了一個靜態的Thread.Sleep方法,它能使一個線程自動的掛起一定的時間,然後自動的重新開始。一個線程能在它自身內部調用Thread.Sleep方法,也能在自身內部調用Thread.Suspend方法,可是一定要別的線程來調用它的Thread.Resume方法才可以重新開始。這一點是不是很容易想通的啊?下面的例子顯示了如何運用Thread.Sleep方法:
   
   
  while (ContinueDrawing) {
   
  DrawNextSlide ();
   
  Thread.Sleep (5000);
   
  }
   
   
   
   
  終止線程

  在托管的代碼中,你可以通過以下的語句在一個線程中將另一個線程終止掉:
   
   
  thread.Abort ();
   
   
  下面我們來解釋一下Abort()方法是如何工作的。因為公用語言運行時管理了所有的托管的線程,同樣它能在每個線程內拋出異常。Abort()方法能在目標線程中拋出一個ThreadAbortException異常從而導致目標線程的終止。不過Abort()方法被調用後,目標線程可能並不是馬上就終止了。因為只要目標線程正在調用非托管的代碼而且還沒有返回的話,該線程就不會立即終止。而如果目標線程在調用非托管的代碼而且陷入了一個死循環的話,該目標線程就根本不會終止。不過這種情況只是一些特例,更多的情況是目標線程在調用托管的代碼,一旦Abort()被調用那麼該線程就立即終止了。
   
   
  在實際應用中,一個線程終止了另一個線程,不過往往要等那個線程完全終止了它才可以繼續運行,這樣的話我們就應該用到它的Join()方法。示例代碼如下:
   
   
  thread.Abort (); // 要求終止另一個線程
   
  thread.Join (); // 只到另一個線程完全終止了,它才繼續運行
   
   
   
  但是如果另一個線程一直不能終止的話(原因如前所述),我們就需要給Join()方法設置一個時間限制,方法如下:
   
   
  thread.Join (5000); // 暫停5秒
   
   
   
  這樣,在5秒後,不管那個線程有沒有完全終止,本線程就強行運行了。該方法還返回一個布爾型的值,如果是true則表明那個線程已經完全終止了,而如果是false的話,則表明已經超過了時間限制了。
   
   
  時鐘線程

  .Net框架中的Timer類可以讓你使用時鐘線程,它是包含在System.Threading名字空間中的,它的作用就是在一定的時間間隔後調用一個線程的方法。下面我給大家展示一個具體的實例,該實例以1秒為時間間隔,在控制台中輸出不同的字符串,代碼如下:
   
   
  using System;
   
  using System.Threading;
   
  class MyApp
   
  {
   
  private static bool TickNext = true;
   
  public static void Main ()
   
  {
   
  Console.WriteLine ("Press Enter to terminate...");
   
  TimerCallback callback = new TimerCallback (TickTock);
   
  Timer timer = new Timer (callback, null, 1000, 1000);
   
  Console.ReadLine ();
   
  }
   
  private static void TickTock (object state)
   
  {
   
  Console.WriteLine (TickNext ? "Tick" : "Tock");
   
  TickNext = ! TickNext;
   
  }
   
  }
   
   
   
  從上面的代碼中,我們知道第一個函數回調是在1000毫秒後才發生的,以後的函數回調也是在每隔1000毫秒之後發生的,這是由Timer對象的構造函數中的第三個參數所決定的。程序會在1000毫秒的時間間隔後不斷的產生新線程,只到用戶輸入回車才結束運行。不過值得注意的是,雖然我們設置了時間間隔為1000毫秒,但是實際運行的時候往往並不能非常精確。因為Windows操作系統並不是一個實時系統,而公用語言運行時也不是實時的,所以由於線程調度的千變萬化,實際的運行效果往往是不能精確到毫秒級的,但是對於一般的應用來說那已經是足夠的了,所以你也不必十分苛求。
   
   
   
  小結

  本文介紹了在.Net下進行多線程編程所需要掌握的一些基本知識。從文章中我們可以知道在.Net下進行多線程編程相對以前是有了大大的簡化,但是其功能並沒有被削弱。使用以上的一些基本知識,讀者就可以試著編寫.Net下的多線程程序了。不過要編寫出功能更加強大而且Bug少的多線程應用程序,讀者需要掌握諸如線程同步、線程池等高級的多線程編程技術。讀者不妨參考一些操作系統方面或是多線程編程方面的技術叢書。

TOP

.NET多線程編程(2):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命名空間還包含了線程鎖定、線程同步何通訊、多線程管理類以及死鎖解決等等高級特性,在後面的部分我們將繼續討論這些內容。

TOP

.NET多線程編程(3):線程同步



隨著對多線程學習的深入,你可能覺得需要瞭解一些有關線程共享資源的問題. .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操作;盡可能的使用局部變量來代替全局變量;同步用在那些部分代碼被多個線程和進程訪問和狀態被不同的進程共享的地方;安排你的代碼使得每一個數據在一個線程裡得到精確的控制;不是共享在線程之間的代碼是安全的;在下一篇文章中我們將學習線程池有關的知識.

TOP

.NET多線程編程(4):線程池和異步編程



如果你仔細閱讀了我前面的三篇文章,我相信你對用.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>

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等。



後記

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

TOP

NET多線程編程(5)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,換一句話說就是等待他們完成了各自的任務。

TOP

發新話題

本站所有圖文均屬網友發表,僅代表作者的觀點與本站無關,如有侵權請通知版主會盡快刪除。