多線程：C#線程同步lock,Monitor,Mutex,同步事件和等待控制代碼

轉自：http://www.cnblogs.com/freshman0216/archive/2008/07/29/1252253.html
 本篇從Monitor，Mutex，ManualResetEvent，AutoResetEvent，WaitHandler的類別關係圖開始， 希望通過本篇的介紹能對常見的線程同步方法有一個整體的認識，而對每種方式的使用細節，適用場合不會過多解釋。讓我們來看看這幾個類的關係圖：

 

      1.lock關鍵字

      lock是C#關鍵詞，它將語句塊標記為臨界區,確保當一個線程位於代碼的臨界區時，另一個線程不進入臨界區。如果其他線程試圖進入鎖定的代碼，則它將一直等待（即被阻止），直到該對象被釋放。方法是擷取給定對象的互斥鎖，執行語句，然後釋放該鎖。

      MSDN上給出了使用lock時的注意事項通常，應避免鎖定 public 類型，否則執行個體將超出代碼的控制範圍。常見的結構 lock (this)、lock (typeof (MyType)) 和 lock ("myLock") 違反此準則。

      1）如果執行個體可以被公用訪問，將出現 lock (this) 問題。

      2）如果 MyType 可以被公用訪問，將出現 lock (typeof (MyType)) 問題由於一個類的所有執行個體都只有一個類型對象（該對象是typeof的返回結果），鎖定它，就鎖定了該對象的所有執行個體。微軟現在建議不要使用 lock(typeof(MyType)),因為鎖定類型對象是個很緩慢的過程，並且類中的其他線程、甚至在同一個應用程式定義域中啟動並執行其他程式都可以訪問 該類型對象，因此，它們就有可能代替您鎖定類型對象，完全阻止您的執行，從而導致你自己的代碼的掛起。

      3）由於進程中使用同一字串的任何其他代碼將共用同一個鎖，所以出現 lock(“myLock”) 問題。這個問題和.NET Framework建立字串的機制有關係，如果兩個string變數值都是"myLock"，在記憶體中會指向同一字串對象。

 

      最佳做法是定義 private 對象來鎖定, 或 private static物件變數來保護所有執行個體所共有的資料。

      我們再來通過IL Dasm看看lock關鍵字的本質，下面是一段簡單的測試代碼：

    lock (lockobject)
    {
        int i = 5;
    }

 

      用IL Dasm開啟編譯後的檔案，上面的語句塊產生的IL代碼為：

      IL_0045:  call       void [mscorlib]System.Threading.Monitor::Enter(object)
      IL_004a:  nop
      .try
      {
        IL_004b:  nop
        IL_004c:  ldc.i4.5
        IL_004d:  stloc.1
        IL_004e:  nop
        IL_004f:  leave.s    IL_0059
      }  // end .try
      finally
      {
        IL_0051:  ldloc.3
        IL_0052:  call       void [mscorlib]System.Threading.Monitor::Exit(object)
        IL_0057:  nop
        IL_0058:  endfinally
      }  // end handler

      通過上面的代碼我們很清楚的看到：lock關鍵字其實就是對Monitor類的Enter()和Exit()方法的封裝，並通過try...catch...finally語句塊確保在lock語句塊結束後執行Monitor.Exit()方法，釋放互斥鎖。

      2.Monitor類

      Monitor類通過向單個線程授予對象鎖來控制對對象的訪問。對象鎖提供限制訪問臨界區的能力。當一個線程擁有對象的鎖時，其他任何 線程都不能擷取該鎖。還可以使用 Monitor 來確保不會允許其他任何線程訪問正在由鎖的所有者執行的應用程式代碼節，除非另一個線程正在使用其他的鎖定對象執行該代碼。

      通過對lock關鍵字的分析我們知道，lock就是對Monitor的Enter和Exit的一個封裝，而且使用起來更簡潔，因此Monitor類的Enter()和Exit()方法的組合使用可以用lock關鍵字替代。

      另外Monitor類還有幾個常用的方法：

      TryEnter()能夠有效解決長期死等的問題，如果在一個並發經常發生，而且期間長的環境中使用TryEnter，可以有效防止死結或者長時間 的等待。比如我們可以設定一個等待時間bool gotLock = Monitor.TryEnter(myobject,1000),讓當前線程在等待1000秒後根據返回的bool值來決定是否繼續下面的操作。

      Wait()釋放對象上的鎖以便允許其他線程鎖定和訪問該對象。在其他線程訪問對象時，調用線程將等待。脈衝訊號用於通知等待線程有關對象狀態的更改。

      Pulse(),PulseAll()向一個或多個等待線程發送訊號。該訊號通知等待線程鎖定對象的狀態已更改，並且鎖的所有者準備釋放該鎖。等待線程被 放置在對象的就緒隊列中以便它可以最後接收對象鎖。一旦線程擁有了鎖，它就可以檢查對象的新狀態以查看是否達到所需狀態。

      注意：Pulse、PulseAll和Wait方法必須從同步的代碼塊內調用。

      我們假定一種情景：媽媽做蛋糕，小孩有點饞，媽媽每做好一塊就要吃掉，媽媽做好一塊後，告訴小孩蛋糕已經做好了。下面的例子用Monitor類的Wait和Pulse方法類比小孩吃蛋糕的情景。

 

 

      這個例子的目的是要理解Wait和Pulse如何保證線程同步的，同時要注意Wait(obeject)和Wait(object,int)方法的區別，理解它們的區別很關鍵的一點是要理解同步的對象包含若干引用，其中包括對當前擁有鎖的線程的引用、對就緒隊列（包含準備擷取鎖的線程）的引用和對等待隊列（包含等待對象狀態更改通知的線程）的引用。

  本篇繼續介紹WaitHandler類及其子類Mutex，ManualResetEvent，AutoResetEvent的用法。.NET中線程同步的方式多的讓人看了眼花繚亂，究竟該怎麼去理解呢？其實，我們拋開.NET環境看線程同步，無非是執行兩種操作：一是互斥/加鎖，目的是保證臨界區代碼操作的“原子性”；另一種是號誌操作，目的是保證多個線程按照一定順序執行，如生產者線程要先於消費者線程執行。.NET中線程同步的類無非是對這兩種方式的封裝，目的歸根結底都可以歸結為實現互斥/加鎖或者是號誌這兩種方式，只是它們的適用場合有所不。下面我們根據類的階層瞭解WaitHandler及其子類。

      1.WaitHandler

      WaitHandle是Mutex，Semaphore，EventWaitHandler，AutoResetEvent，ManualResetEvent共同的祖先，它封裝Win32同步控制代碼核心對象，也就是說是這些核心對象的託管版本。

      線程可以通過調用WaitHandler執行個體的方法WaitOne在單個等待控制代碼上阻止。此外，WaitHandler類重載了靜態方法，以等待所有指 定的等待控制代碼都已收集到訊號WaitAll，或者等待某一指定的等待控制代碼收集到訊號WaitAny。這些方法都提供了放棄等待的逾時間隔、在進入等待之前 退出同步內容相關的機會，並允許其它線程使用同步上下文。WaitHandler是C#中的抽象類別，不能執行個體化。

      2.EventWaitHandler vs. ManualResetEvent vs. AutoResetEvent（同步事件）

      我們先看看兩個子類ManualResetEvent和AutoResetEvent在.NET Framework中的實現：

 

      原來ManualResetEvent和AutoResetEvent都繼承自EventWaitHandler，它們的唯一區別就在於父類 EventWaitHandler的建構函式參數EventResetMode不同，這樣我們只要弄清了參數EventResetMode值不同 時，EventWaitHandler類控制線程同步的行為有什麼不同，兩個子類也就清楚了。為了便於描述，我們不去介紹父類的兩種模式，而直接介紹子 類。

      ManualResetEvent和AutoResetEvent的共同點：
      1）Set方法將事件狀態設定為終止狀態，允許一個或多個等待線程繼續；Reset方法將事件狀態設定為非終止狀態，導致線程阻止；WaitOne阻止當前線程，直到當前線程的WaitHandler收到事件訊號。
      2）可以通過建構函式的參數值來決定其初始狀態，若為true則事件為終止狀態從而使線程為非阻塞狀態，為false則線程為阻塞狀態。
      3）如果某個線程調用WaitOne方法，則當事件狀態為終止狀態時，該線程會得到訊號，繼續向下執行。

      ManualResetEvent和AutoResetEvent的不同點：
      1）AutoResetEvent.WaitOne()每次只允許一個線程進入，當某個線程得到訊號後，AutoResetEvent會自動又將訊號置為不發送狀態，則其他調用WaitOne的線程只有繼續等待，也就是說AutoResetEvent一次只喚醒一個線程；
      2）ManualResetEvent則可以喚醒多個線程，因為當某個線程調用了ManualResetEvent.Set()方法後，其他調用WaitOne的線程獲得訊號得以繼續執行，而ManualResetEvent不會自動將訊號置為不發送。
      3）也就是說，除非手工調用了ManualResetEvent.Reset()方法，則ManualResetEvent將一直保持有訊號狀態，ManualResetEvent也就可以同時喚醒多個線程繼續執行。

      樣本情境：張三、李四兩個好朋友去餐館吃飯，兩個人點了一份宮爆雞丁，宮爆雞丁做好需要一段時間，張三、李四不願傻等，都專心致志的玩 起了手機遊戲，心想宮爆雞丁做好了，服務員肯定會叫我們的。服務員上菜之後，張三李四開始享用美味的飯菜，飯菜吃光了，他們再叫服務員過來買單。我們可以 從這個情境中抽象出來三個線程，張三線程、李四線程和服務員線程，他們之間需要同步：服務員上菜—>張三、李四開始享用宮爆雞丁—>吃好後叫 服務員過來買單。這個同步用什麼呢？ ManualResetEvent還是AutoResetEvent？通過上面的分析不難看出，我們應該用 ManualResetEvent進行同步，下面是程式碼：

 

   
      編譯後查看運行結果，符合我們的預期，控制台輸出為：
      服務員：廚師在做菜呢，兩位稍等...
      張三：等著上菜無聊先玩會手機遊戲
      李四：等著上菜無聊先玩會手機遊戲
      張三：等著上菜無聊先玩會手機遊戲
      李四：等著上菜無聊先玩會手機遊戲
      服務員：宮爆雞丁好了
      張三：開始吃宮爆雞丁
      李四：開始吃宮爆雞丁
      張三：宮爆雞丁吃光了
      李四：宮爆雞丁吃光了
      服務員：兩位請買單

      如果改用AutoResetEvent進行同步呢？會出現什麼樣的結果？恐怕張三和李四就 要打起來了，一個享用了美味的宮爆雞丁，另一個到要付賬的時候卻還在玩遊戲。感興趣的朋友可以把注釋的那行代碼注釋去掉，並把下面一行代碼注釋掉，運行程 序看會出現怎樣的結果。

       3.Mutex(互斥體）

       Mutex和EventWaitHandler有著共同的父類WaitHandler類，它們同步的函數用法也差不多，這裡不再贅述。Mutex的突出特點是可以跨應用程式定義域邊界對資源進行獨佔訪問，即可以用於同步不同進程中的線程，這種功能當然這是以犧牲更多的系統資源為代價的。

  前兩篇簡單介紹了線程同步lock，Monitor，同步事件EventWaitHandler，互斥體Mutex的基本用法，在此基礎上，我們對它們用法進行比較，並給出什麼時候需要鎖什麼時候不需要的幾點建議。最後，介紹幾個FCL中安全執行緒的類，集合類的鎖定方式等，做為對線程同步系列的完善和補充。

      1.幾種同步方法的區別

      lock和Monitor是.NET用一個特殊結構實現的，Monitor對象是完全託管的、完全可移植的，並且在作業系統資源要求方面可能更為有效，同步速度較快，但不能跨進程同步。lock（Monitor.Enter和Monitor.Exit方法的封裝），主要作用是鎖定臨界區，使臨界區代碼只能被獲得鎖的線程執行。Monitor.Wait和Monitor.Pulse用於線程同步，類似訊號操作，個人感覺使用比較複雜，容易造成死結。

      互斥體Mutex和事件對象EventWaitHandler屬於核心對象，利用核心對象進行線程同步，線程必須要在使用者模式和核心模式間切換，所以一般效率很低，但利用互斥對象和事件對象這樣的核心對象，可以在多個進程中的各個線程間進行同步。

      互斥體Mutex類似於一個接力棒，拿到接力棒的線程才可以開始跑，當然接力棒一次只屬於一個線程(Thread Affinity)，如果這個線程不釋放接力棒(Mutex.ReleaseMutex)，那麼沒辦法，其他所有需要接力棒啟動並執行線程都知道能等著看熱鬧。

      EventWaitHandle 類允許線程通過發訊號互相通訊。通常，一個或多個線程在 EventWaitHandle 上阻止，直到一個未阻止的線程調用 Set 方法，以釋放一個或多個被阻止的線程。

      2.什麼時候需要鎖定

      首先要理解鎖定是解決競爭條件的，也就是多個線程同時訪問某個資源，造成意想不到的結果。比如，最簡單的情況是，一個計數器，兩個線程 同時加一，後果就是損失了一個計數，但相當頻繁的鎖定又可能帶來效能上的消耗，還有最可怕的情況死結。那麼什麼情況下我們需要使用鎖，什麼情況下不需要 呢？

      1）只有共用資源才需要鎖定
      只有可以被多線程訪問的共用資源才需要考慮鎖定，比如靜態變數，再比如某些緩衝中的值，而屬於線程內部的變數不需要鎖定。 

      2）多使用lock,少用Mutex
      如果你一定要使用鎖定，請盡量不要使用核心模組的鎖定機制，比如.NET的Mutex，Semaphore，AutoResetEvent和 ManuResetEvent，使用這樣的機制涉及到了系統在使用者模式和核心模式間的切換，效能差很多，但是他們的優點是可以跨進程同步線程，所以應該清 楚的瞭解到他們的不同和適用範圍。

      3）瞭解你的程式是怎麼啟動並執行
      實際上在web開發中大多數邏輯都是在單個線程中展開的，一個請求都會在一個單獨的線程中處理，其中的大部分變數都是屬於這個線程的，根本沒有必要考慮鎖定，當然對於ASP.NET中的Application對象中的資料，我們就要考慮加鎖了。

      4）把鎖定交給資料庫
      數 據庫除了儲存資料之外，還有一個重要的用途就是同步，資料庫本身用了一套複雜的機制來保證資料的可靠和一致性，這就為我們節省了很多的精力。保證了資料來源 頭上的同步，我們多數的精力就可以集中在緩衝等其他一些資源的同步訪問上了。通常，只有涉及到多個線程修改資料庫中同一條記錄時，我們才考慮加鎖。 

      5）商務邏輯對事務和安全執行緒的要求
      這 條是最根本的東西，開發完全安全執行緒的程式是件很費時費力的事情，在電子商務等涉及金融系統的案例中，許多邏輯都必須嚴格的安全執行緒，所以我們不得不犧牲 一些效能，和很多的開發時間來做這方面的工作。而一般的應用中，許多情況下雖然程式有競爭的危險，我們還是可以不使用鎖定，比如有的時候計數器少一多一， 對結果無傷大雅的情況下，我們就可以不用去管它。

      3.InterLocked類

      Interlocked 類提供了同步對多個線程共用的變數的訪問的方法。如果該變數位於共用記憶體中，則不同進程的線程就可以使用該機制。互鎖操作是原子的，即整個操作是不能由相 同變數上的另一個互鎖操作所中斷的單元。這在搶先多線程作業系統中是很重要的，在這樣的作業系統中，線程可以在從某個記憶體位址載入值之後但是在有機會更改 和儲存該值之前被掛起。

      我們來看一個InterLock.Increment()的例子，該方法以原子的形式遞增指定變數並儲存結果，樣本如下：

    class InterLockedTest
    {
        public static Int64 i = 0;

        public static void Add()
        {
            for (int i = 0; i < 100000000; i++)
            {
                Interlocked.Increment(ref InterLockedTest.i);
                //InterLockedTest.i = InterLockedTest.i + 1;
            }
        }

        public static void Main(string[] args)
        {
            Thread t1 = new Thread(new ThreadStart(InterLockedTest.Add));
            Thread t2 = new Thread(new ThreadStart(InterLockedTest.Add));

            t1.Start();
            t2.Start();

            t1.Join();
            t2.Join();

            Console.WriteLine(InterLockedTest.i.ToString());
            Console.Read();
        }
    }

 

      輸出結果200000000，如果InterLockedTest.Add()方法中用注釋掉的語句代替Interlocked.Increment()方法，結果將不可預知，每次執行結果不同。InterLockedTest.Add()方法保證了加1操作的原子性，功能上相當於自動給加操作使用了lock鎖。同時我們也注意到InterLockedTest.Add()用時比直接用+號加1要耗時的多，所以說加鎖資源損耗還是很明顯的。

      另外InterLockedTest類還有幾個常用方法，具體用法可以參考MSDN上的介紹。

      4.集合類的同步

      .NET在一些集合類，比如Queue、ArrayList、HashTable和Stack，已經提供了一個供lock使用的對象SyncRoot。用Reflector查看了SyncRoot屬性（Stack.SynchRoot略有不同）的源碼如下：

public virtual object SyncRoot
{
    get
    {
        if (this._syncRoot == null)
        {
            //如果_syncRoot和null相等，將new object賦值給_syncRoot
            //Interlocked.CompareExchange方法保證多個線程在使用syncRoot時是安全執行緒的
            Interlocked.CompareExchange(ref this._syncRoot, new object(), null);
        }
        return this._syncRoot;
    }
}

      這裡要特別注意的是MSDN提到：從頭到尾對一個集合進行枚舉本質上並不是一個安全執行緒的過程。即使一個集合已進行同步，其他線程仍可以修改該集合，這將導致枚舉數引發異常。若要在枚舉過程中保證安全執行緒，可以在整個枚舉過程中鎖定集合，或者捕捉由於其他線程進行的更改而引發的異常。應該使用下面的代碼：

    Queue q = new Queue();
    lock (q.SyncRoot)
    {
        foreach (object item in q)
        {
            //do something
        }
    }

      還有一點需要說明的是，集合類提供了一個是和同步相關的方法Synchronized，該 方法返回一個對應的集合類的wrapper類，該類是安全執行緒的，因為他的大部分方法都用lock關鍵字進行了同步處理。如HashTable的 Synchronized返回一個新的安全執行緒的HashTable執行個體，代碼如下：

    //在多線程環境中只要我們用下面的方式執行個體化HashTable就可以了
    Hashtable ht = Hashtable.Synchronized(new Hashtable());

    //以下代碼是.NET Framework Class Library實現，增加對Synchronized的認識
    [HostProtection(SecurityAction.LinkDemand, Synchronization=true)]
    public static Hashtable Synchronized(Hashtable table)
    {
        if (table == null)
        {
            throw new ArgumentNullException("table");
        }
        return new SyncHashtable(table);
    }

 
    //SyncHashtable的幾個常用方法，我們可以看到內部實現都加了lock關鍵字保證安全執行緒
    public override void Add(object key, object value)
    {
        lock (this._table.SyncRoot)
        {
            this._table.Add(key, value);
        }
    }

    public override void Clear()
    {
        lock (this._table.SyncRoot)
        {
            this._table.Clear();
        }
    }

    public override void Remove(object key)
    {
        lock (this._table.SyncRoot)
        {
            this._table.Remove(key);
        }
    }

      線程同步是一個非常複雜的話題，這裡只是根據公司的一個項目把相關的知識整理出來，作為工作的一種總結。這些同步方法的使用情境是怎樣的？究竟有哪些細微的差別？還有待於進一步的學習和實踐。

引用自：http://www.haogongju.net/art/630286