c#線程同步使用詳解示例

更新時(shí)間：2014年02月11日 10:39:47 作者：

這篇文章主要介紹了c#線程同步使用方法,介紹幾種常用的C#進(jìn)行線程同步的方式,需要的朋友可以參考下

在應(yīng)用程序中使用多個(gè)線程的一個(gè)好處是每個(gè)線程都可以異步執(zhí)行。對(duì)于 Windows 應(yīng)用程序，耗時(shí)的任務(wù)可以在后臺(tái)執(zhí)行，而使應(yīng)用程序窗口和控件保持響應(yīng)。對(duì)于服務(wù)器應(yīng)用程序，多線程處理提供了用不同線程處理每個(gè)傳入請(qǐng)求的能力。否則，在完全滿足前一個(gè)請(qǐng)求之前，將無法處理每個(gè)新請(qǐng)求。然而，線程的異步特性意味著必須協(xié)調(diào)對(duì)資源（如文件句柄、網(wǎng)絡(luò)連接和內(nèi)存）的訪問。否則，兩個(gè)或更多的線程可能在同一時(shí)間訪問相同的資源，而每個(gè)線程都不知道其他線程的操作。

線程同步的方式

線程同步有：臨界區(qū)、互斥區(qū)、事件、信號(hào)量四種方式
臨界區(qū)（Critical Section）、互斥量（Mutex）、信號(hào)量（Semaphore）、事件（Event）的區(qū)別
1、臨界區(qū)：通過對(duì)多線程的串行化來訪問公共資源或一段代碼，速度快，適合控制數(shù)據(jù)訪問。在任意時(shí)刻只允許一個(gè)線程對(duì)共享資源進(jìn)行訪問，如果有多個(gè)線程試圖訪問公共資源，那么在有一個(gè)線程進(jìn)入后，其他試圖訪問公共資源的線程將被掛起，并一直等到進(jìn)入臨界區(qū)的線程離開，臨界區(qū)在被釋放后，其他線程才可以搶占。
2、互斥量：采用互斥對(duì)象機(jī)制。只有擁有互斥對(duì)象的線程才有訪問公共資源的權(quán)限，因?yàn)榛コ鈱?duì)象只有一個(gè)，所以能保證公共資源不會(huì)同時(shí)被多個(gè)線程訪問?；コ獠粌H能實(shí)現(xiàn)同一應(yīng)用程序的公共資源安全共享，還能實(shí)現(xiàn)不同應(yīng)用程序的公共資源安全共享
3、信號(hào)量：它允許多個(gè)線程在同一時(shí)刻訪問同一資源，但是需要限制在同一時(shí)刻訪問此資源的最大線程數(shù)目
4、事件：通過通知操作的方式來保持線程的同步，還可以方便實(shí)現(xiàn)對(duì)多個(gè)線程的優(yōu)先級(jí)比較的操作

C#中常見線程同步方法

我們介紹幾種常用的C#進(jìn)行線程同步的方式，這些方式可以根據(jù)其原理，找到對(duì)應(yīng)上面的四種類型之一。

1、Interlocked
為多個(gè)線程共享的變量提供原子操作。

根據(jù)經(jīng)驗(yàn)，那些需要在多線程情況下被保護(hù)的資源通常是整型值，且這些整型值在多線程下最常見的操作就是遞增、遞減或相加操作。Interlocked類提供了一個(gè)專門的機(jī)制用于完成這些特定的操作。這個(gè)類提供了Increment、Decrement、Add靜態(tài)方法用于對(duì)int或long型變量的遞增、遞減或相加操作。此類的方法可以防止可能在下列情況發(fā)生的錯(cuò)誤：計(jì)劃程序在某個(gè)線程正在更新可由其他線程訪問的變量時(shí)切換上下文；或者當(dāng)兩個(gè)線程在不同的處理器上并發(fā)執(zhí)行時(shí)。此類的成員不引發(fā)異常。

Increment和Decrement方法遞增或遞減變量并將結(jié)果值存儲(chǔ)在單個(gè)操作中。在大多數(shù)計(jì)算機(jī)上，增加變量操作不是一個(gè)原子操作，需要執(zhí)行下列步驟：

1)將實(shí)例變量中的值加載到寄存器中。
2)增加或減少該值。
3)在實(shí)例變量中存儲(chǔ)該值。
如果不使用 Increment 和 Decrement，線程會(huì)在執(zhí)行完前兩個(gè)步驟后被搶先。然后由另一個(gè)線程執(zhí)行所有三個(gè)步驟。當(dāng)?shù)谝粋€(gè)線程重新開始執(zhí)行時(shí)，它覆蓋實(shí)例變量中的值，造成第二個(gè)線程執(zhí)行增減操作的結(jié)果丟失。

Exchange 方法自動(dòng)交換指定變量的值。 CompareExchange 方法組合了兩個(gè)操作：比較兩個(gè)值以及根據(jù)比較的結(jié)果將第三個(gè)值存儲(chǔ)在其中一個(gè)變量中。比較和交換操作按原子操作執(zhí)行。

案例分析：共享打印機(jī)。

通常我們會(huì)使用共享打印機(jī)，幾臺(tái)計(jì)算機(jī)共享一臺(tái)打印機(jī)，每臺(tái)計(jì)算機(jī)可以發(fā)出打印指令，可能會(huì)出現(xiàn)并發(fā)情況。當(dāng)然我們知道，打印機(jī)采用了隊(duì)列技術(shù)。為了簡(jiǎn)化操作，我們假定，在打印機(jī)收到命令時(shí)，即可打印，而且在同一時(shí)間只能有一個(gè)打印任務(wù)在執(zhí)行。我們使用Interlocked方法來實(shí)現(xiàn)多線程同步。具體代碼如下：

復(fù)制代碼代碼如下:

using System;
using System.Threading;

namespace MutiThreadSample.ThreadSynchronization
{
    class PrinterWithInterlockTest
    {
   /// <summary>
   /// 正在使用的打印機(jī)
   /// 0代表未使用，1代表正在使用
   /// </summary>
   public static int UsingPrinter = 0;
   /// <summary>
   /// 計(jì)算機(jī)數(shù)量
   /// </summary>
   public static readonly int ComputerCount = 3;
   /// <summary>
   /// 測(cè)試
   /// </summary>
   public static void TestPrint()
   {
Thread thread;
Random random = new Random();
for (int i = 0; i < ComputerCount; i++)
{
thread = new Thread(MyThreadProc);
thread.Name = string.Format("Thread{0}",i);
Thread.Sleep(random.Next(3));
thread.Start();
}
   }
   /// <summary>
   /// 線程執(zhí)行操作
   /// </summary>
   private static void MyThreadProc()
   {
//使用打印機(jī)進(jìn)行打印
UsePrinter();
//當(dāng)前線程等待1秒
Thread.Sleep(1000);
   }
   /// <summary>
   /// 使用打印機(jī)進(jìn)行打印
   /// </summary>
   private static bool UsePrinter()
   {
//檢查大引進(jìn)是否在使用，如果原始值為0，則為未使用，可以進(jìn)行打印，否則不能打印，繼續(xù)等待
if (0 == Interlocked.Exchange(ref UsingPrinter, 1))
{
Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name);

//Code to access a resource that is not thread safe would go here.

//Simulate some work
Thread.Sleep(500);

Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name);

//釋放打印機(jī)
Interlocked.Exchange(ref UsingPrinter, 0);
return true;
}
else
{
Console.WriteLine(" {0} was denied the lock", Thread.CurrentThread.Name);
return false;
}
}

}
}

2、lock 關(guān)鍵字

lock 關(guān)鍵字將語句塊標(biāo)記為臨界區(qū)，方法是獲取給定對(duì)象的互斥鎖，執(zhí)行語句，然后釋放該鎖。
lock 確保當(dāng)一個(gè)線程位于代碼的臨界區(qū)時(shí)，另一個(gè)線程不進(jìn)入臨界區(qū)。如果其他線程試圖進(jìn)入鎖定的代碼，則它將一直等待（即被阻止），直到該對(duì)象被釋放。

復(fù)制代碼代碼如下:

public void Function()
{
 System.Object locker= new System.Object();
 lock(locker)
{
 // Access thread-sensitive resources.
}
} 

lock 調(diào)用塊開始位置的 Enter 和塊結(jié)束位置的 Exit。

提供給 lock 關(guān)鍵字的參數(shù)必須為基于引用類型的對(duì)象，該對(duì)象用來定義鎖的范圍。在上例中，鎖的范圍限定為此函數(shù)，因?yàn)楹瘮?shù)外不存在任何對(duì)該對(duì)象的引用。嚴(yán)格地說，提供給 lock 的對(duì)象只是用來唯一地標(biāo)識(shí)由多個(gè)線程共享的資源，所以它可以是任意類實(shí)例。然而，實(shí)際上，此對(duì)象通常表示需要進(jìn)行線程同步的資源。例如，如果一個(gè)容器對(duì)象將被多個(gè)線程使用，則可以將該容器傳遞給 lock，而 lock 后面的同步代碼塊將訪問該容器。只要其他線程在訪問該容器前先鎖定該容器，則對(duì)該對(duì)象的訪問將是安全同步的。通常，最好避免鎖定 public 類型或鎖定不受應(yīng)用程序控制的對(duì)象實(shí)例，例如，如果該實(shí)例可以被公開訪問，則 lock(this) 可能會(huì)有問題，因?yàn)椴皇芸刂频拇a也可能會(huì)鎖定該對(duì)象。這可能導(dǎo)致死鎖，即兩個(gè)或更多個(gè)線程等待釋放同一對(duì)象。出于同樣的原因，鎖定公共數(shù)據(jù)類型（相比于對(duì)象）也可能導(dǎo)致問題。鎖定字符串尤其危險(xiǎn)，因?yàn)樽址还舱Z言運(yùn)行庫 (CLR)“暫留”。這意味著整個(gè)程序中任何給定字符串都只有一個(gè)實(shí)例，就是這同一個(gè)對(duì)象表示了所有運(yùn)行的應(yīng)用程序域的所有線程中的該文本。因此，只要在應(yīng)用程序進(jìn)程中的任何位置處具有相同內(nèi)容的字符串上放置了鎖，就將鎖定應(yīng)用程序中該字符串的所有實(shí)例。因此，最好鎖定不會(huì)被暫留的私有或受保護(hù)成員。某些類提供專門用于鎖定的成員。例如，Array 類型提供 SyncRoot。許多集合類型也提供 SyncRoot。

常見的結(jié)構(gòu) lock (this)、lock (typeof (MyType)) 和 lock ("myLock") 違反此準(zhǔn)則：

1）如果實(shí)例可以被公共訪問，將出現(xiàn) lock (this) 問題。
2）如果 MyType 可以被公共訪問，將出現(xiàn) lock (typeof (MyType)) 問題。
3）由于進(jìn)程中使用同一字符串的任何其他代碼將共享同一個(gè)鎖，所以出現(xiàn) lock(“myLock”) 問題。
最佳做法是定義 private 對(duì)象來鎖定, 或 private static 對(duì)象變量來保護(hù)所有實(shí)例所共有的數(shù)據(jù)。關(guān)于鎖的研究，大家可以參考：

案例分析：繼續(xù)使用共享打印機(jī)的案例

我們只需對(duì)前面的例子稍作修改即可實(shí)現(xiàn)lock進(jìn)行同步。

聲明鎖對(duì)象：

復(fù)制代碼代碼如下:

/// <summary>
/// 正在使用的打印機(jī)
/// </summary>
private static object UsingPrinterLocker = new object();

將打印方法修改如下：

復(fù)制代碼代碼如下:

/// <summary>
/// 使用打印機(jī)進(jìn)行打印
/// </summary>
private static void UsePrinter()
{
  //臨界區(qū)
  lock (UsingPrinterLocker)
  {
 Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name);
 //模擬打印操作
 Thread.Sleep(500);
 Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name);
  }
}

3、監(jiān)視器

與 lock 關(guān)鍵字類似，監(jiān)視器防止多個(gè)線程同時(shí)執(zhí)行代碼塊。Enter 方法允許一個(gè)且僅一個(gè)線程繼續(xù)執(zhí)行后面的語句；其他所有線程都將被阻止，直到執(zhí)行語句的線程調(diào)用 Exit。這與使用 lock 關(guān)鍵字一樣。事實(shí)上，lock 關(guān)鍵字就是用 Monitor 類來實(shí)現(xiàn)的。例如：（繼續(xù)修改共享打印機(jī)案例，增加方法UsePrinterWithMonitor）

復(fù)制代碼代碼如下:

/// <summary>
/// 使用打印機(jī)進(jìn)行打印
/// </summary>
private static void UsePrinterWithMonitor()
{
  System.Threading.Monitor.Enter(UsingPrinterLocker);
  try
  {
 Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name);
 //模擬打印操作
 Thread.Sleep(500);
 Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name);
  }
  finally
  {
 System.Threading.Monitor.Exit(UsingPrinterLocker);
  }
}

使用 lock 關(guān)鍵字通常比直接使用 Monitor 類更可取，一方面是因?yàn)?lock 更簡(jiǎn)潔，另一方面是因?yàn)?lock 確保了即使受保護(hù)的代碼引發(fā)異常，也可以釋放基礎(chǔ)監(jiān)視器。這是通過 finally 關(guān)鍵字來實(shí)現(xiàn)的，無論是否引發(fā)異常它都執(zhí)行關(guān)聯(lián)的代碼塊。

4、同步事件和等待句柄

使用鎖或監(jiān)視器對(duì)于防止同時(shí)執(zhí)行區(qū)分線程的代碼塊很有用，但是這些構(gòu)造不允許一個(gè)線程向另一個(gè)線程傳達(dá)事件。這需要“同步事件”，它是有兩個(gè)狀態(tài)（終止和非終止）的對(duì)象，可以用來激活和掛起線程。讓線程等待非終止的同步事件可以將線程掛起，將事件狀態(tài)更改為終止可以將線程激活。如果線程試圖等待已經(jīng)終止的事件，則線程將繼續(xù)執(zhí)行，而不會(huì)延遲。

同步事件有兩種：AutoResetEvent和ManualResetEvent。它們之間唯一的不同在于，無論何時(shí)，只要AutoResetEvent激活線程，它的狀態(tài)將自動(dòng)從終止變?yōu)榉墙K止。相反，ManualResetEvent允許它的終止?fàn)顟B(tài)激活任意多個(gè)線程，只有當(dāng)它的Reset方法被調(diào)用時(shí)才還原到非終止?fàn)顟B(tài)。

等待句柄，可以通過調(diào)用一種等待方法，如WaitOne、WaitAny或WaitAll，讓線程等待事件。System.Threading.WaitHandle.WaitOne使線程一直等待，直到單個(gè)事件變?yōu)榻K止?fàn)顟B(tài)；System.Threading.WaitHandle.WaitAny阻止線程，直到一個(gè)或多個(gè)指示的事件變?yōu)榻K止?fàn)顟B(tài)；System.Threading.WaitHandle.WaitAll阻止線程，直到所有指示的事件都變?yōu)榻K止?fàn)顟B(tài)。當(dāng)調(diào)用事件的Set方法時(shí)，事件將變?yōu)榻K止?fàn)顟B(tài)。

AutoResetEvent允許線程通過發(fā)信號(hào)互相通信。通常，當(dāng)線程需要獨(dú)占訪問資源時(shí)使用該類。線程通過調(diào)用AutoResetEvent上的WaitOne來等待信號(hào)。如果AutoResetEvent為非終止?fàn)顟B(tài)，則線程會(huì)被阻止，并等待當(dāng)前控制資源的線程通過調(diào)用Set來通知資源可用。調(diào)用Set向AutoResetEvent發(fā)信號(hào)以釋放等待線程。AutoResetEvent將保持終止?fàn)顟B(tài)，直到一個(gè)正在等待的線程被釋放，然后自動(dòng)返回非終止?fàn)顟B(tài)。如果沒有任何線程在等待，則狀態(tài)將無限期地保持為終止?fàn)顟B(tài)。如果當(dāng)AutoResetEvent為終止?fàn)顟B(tài)時(shí)線程調(diào)用WaitOne，則線程不會(huì)被阻止。AutoResetEvent將立即釋放線程并返回到非終止?fàn)顟B(tài)。
可以通過將一個(gè)布爾值傳遞給構(gòu)造函數(shù)來控制AutoResetEvent的初始狀態(tài)：如果初始狀態(tài)為終止?fàn)顟B(tài)，則為true；否則為false。
AutoResetEvent也可以同staticWaitAll和WaitAny方法一起使用。
案例：

案例介紹：

今天我們來做飯，做飯呢，需要一菜、一粥。今天我們吃魚。

熬粥和做魚，是比較復(fù)雜的工作流程，
做粥：選材、淘米、熬制
做魚：洗魚、切魚、腌制、烹調(diào)
為了提高效率，我們用兩個(gè)線程來準(zhǔn)備這頓飯，但是，現(xiàn)在只有一口鍋，只能等一個(gè)做完之后，另一個(gè)才能進(jìn)行最后的烹調(diào)。

來看實(shí)例代碼：

復(fù)制代碼代碼如下:

usingSystem;
usingSystem.Threading;

namespaceMutiThreadSample.ThreadSynchronization
{
///<summary>
///案例：做飯
///今天的Dinner準(zhǔn)備吃魚，還要熬粥
///熬粥和做魚，是比較復(fù)雜的工作流程，
///做粥：選材、淘米、熬制
///做魚：洗魚、切魚、腌制、烹調(diào)
///我們用兩個(gè)線程來準(zhǔn)備這頓飯
///但是，現(xiàn)在只有一口鍋，只能等一個(gè)做完之后，另一個(gè)才能進(jìn)行最后的烹調(diào)
///</summary>
classCookResetEvent
{
///<summary>
///
///</summary>
privateAutoResetEventresetEvent=newAutoResetEvent(false);
///<summary>
///做飯
///</summary>
publicvoidCook()
{
ThreadporridgeThread=newThread(newThreadStart(Porridge));
porridgeThread.Name="Porridge";
porridgeThread.Start();

ThreadmakeFishThread=newThread(newThreadStart(MakeFish));
makeFishThread.Name="MakeFish";
makeFishThread.Start();

//等待5秒
Thread.Sleep(5000);

resetEvent.Reset();
}
///<summary>
///熬粥
///</summary>
publicvoidPorridge()
{
//選材
Console.WriteLine("Thread:{0},開始選材",Thread.CurrentThread.Name);

//淘米
Console.WriteLine("Thread:{0},開始淘米",Thread.CurrentThread.Name);

//熬制
Console.WriteLine("Thread:{0},開始熬制，需要2秒鐘",Thread.CurrentThread.Name);
//需要2秒鐘
Thread.Sleep(2000);
Console.WriteLine("Thread:{0},粥已經(jīng)做好，鍋閑了",Thread.CurrentThread.Name);

resetEvent.Set();
}
///<summary>
///做魚
///</summary>
publicvoidMakeFish()
{
//洗魚
Console.WriteLine("Thread:{0},開始洗魚",Thread.CurrentThread.Name);

//腌制
Console.WriteLine("Thread:{0},開始腌制",Thread.CurrentThread.Name);

//等待鍋空閑出來
resetEvent.WaitOne();

//烹調(diào)
Console.WriteLine("Thread:{0},終于有鍋了",Thread.CurrentThread.Name);
Console.WriteLine("Thread:{0},開始做魚,需要5秒鐘",Thread.CurrentThread.Name);
Thread.Sleep(5000);
Console.WriteLine("Thread:{0},魚做好了，好香",Thread.CurrentThread.Name);

resetEvent.Set();
}
}
}

ManualResetEvent與AutoResetEvent用法基本類似，這里不多做介紹。

5、Mutex對(duì)象

mutex與監(jiān)視器類似；它防止多個(gè)線程在某一時(shí)間同時(shí)執(zhí)行某個(gè)代碼塊。事實(shí)上，名稱“mutex”是術(shù)語“互相排斥(mutuallyexclusive)”的簡(jiǎn)寫形式。然而與監(jiān)視器不同的是，mutex可以用來使跨進(jìn)程的線程同步。mutex由Mutex類表示。當(dāng)用于進(jìn)程間同步時(shí)，mutex稱為“命名mutex”，因?yàn)樗鼘⒂糜诹硪粋€(gè)應(yīng)用程序，因此它不能通過全局變量或靜態(tài)變量共享。必須給它指定一個(gè)名稱，才能使兩個(gè)應(yīng)用程序訪問同一個(gè)mutex對(duì)象。
盡管mutex可以用于進(jìn)程內(nèi)的線程同步，但是使用Monitor通常更為可取，因?yàn)楸O(jiān)視器是專門為.NETFramework而設(shè)計(jì)的，因而它可以更好地利用資源。相比之下，Mutex類是Win32構(gòu)造的包裝。盡管mutex比監(jiān)視器更為強(qiáng)大，但是相對(duì)于Monitor類，它所需要的互操作轉(zhuǎn)換更消耗計(jì)算資源。

本地mutex和系統(tǒng)mutex
Mutex分兩種類型：本地mutex和命名系統(tǒng)mutex。如果使用接受名稱的構(gòu)造函數(shù)創(chuàng)建了Mutex對(duì)象，那么該對(duì)象將與具有該名稱的操作系統(tǒng)對(duì)象相關(guān)聯(lián)。命名的系統(tǒng)mutex在整個(gè)操作系統(tǒng)中都可見，并且可用于同步進(jìn)程活動(dòng)。您可以創(chuàng)建多個(gè)Mutex對(duì)象來表示同一命名系統(tǒng)mutex，而且您可以使用OpenExisting方法打開現(xiàn)有的命名系統(tǒng)mutex。
本地mutex僅存在于進(jìn)程當(dāng)中。進(jìn)程中引用本地Mutex對(duì)象的任意線程都可以使用本地mutex。每個(gè)Mutex對(duì)象都是一個(gè)單獨(dú)的本地mutex。

在本地Mutex中，用法與Monitor基本一致

繼續(xù)修改前面的打印機(jī)案例：

聲明Mutex對(duì)象：

復(fù)制代碼代碼如下:

///<summary>
///mutex對(duì)象
///</summary>
privatestaticMutexmutex=newMutex();

具體操作：

復(fù)制代碼代碼如下:

///<summary>
///使用打印機(jī)進(jìn)行打印
///</summary>
privatestaticvoidUsePrinterWithMutex()
{
mutex.WaitOne();
try
{
Console.WriteLine("{0}acquiredthelock",Thread.CurrentThread.Name);
//模擬打印操作
Thread.Sleep(500);
Console.WriteLine("{0}exitinglock",Thread.CurrentThread.Name);
}
finally
{
mutex.ReleaseMutex();
}
}

多線程調(diào)用：

復(fù)制代碼代碼如下:

///<summary>
///測(cè)試
///</summary>
publicstaticvoidTestPrint()
{
Threadthread;
Randomrandom=newRandom();
for(inti=0;i<ComputerCount;i++)
{
thread=newThread(MyThreadProc);
thread.Name=string.Format("Thread{0}",i);
Thread.Sleep(random.Next(3));
thread.Start();
}
}
///<summary>
///線程執(zhí)行操作
///</summary>
privatestaticvoidMyThreadProc()
{
//使用打印機(jī)進(jìn)行打印
//UsePrinter();
//monitor同步
//UsePrinterWithMonitor();
//用Mutex同步
UsePrinterWithMutex();
//當(dāng)前線程等待1秒
Thread.Sleep(1000);
}

最后的打印機(jī)案例代碼：

復(fù)制代碼代碼如下:

usingSystem;
usingSystem.Threading;

namespaceMutiThreadSample.ThreadSynchronization
{
classPrinterWithLockTest
{
///<summary>
///正在使用的打印機(jī)
///</summary>
privatestaticobjectUsingPrinterLocker=newobject();
///<summary>
///計(jì)算機(jī)數(shù)量
///</summary>
publicstaticreadonlyintComputerCount=3;
///<summary>
///mutex對(duì)象
///</summary>
privatestaticMutexmutex=newMutex();
///<summary>
///測(cè)試
///</summary>
publicstaticvoidTestPrint()
{
Threadthread;
Randomrandom=newRandom();
for(inti=0;i<ComputerCount;i++)
{
thread=newThread(MyThreadProc);
thread.Name=string.Format("Thread{0}",i);
Thread.Sleep(random.Next(3));
thread.Start();
}
}
///<summary>
///線程執(zhí)行操作
///</summary>
privatestaticvoidMyThreadProc()
{
//使用打印機(jī)進(jìn)行打印
//UsePrinter();
//monitor同步
//UsePrinterWithMonitor();
//用Mutex同步
UsePrinterWithMutex();
//當(dāng)前線程等待1秒
Thread.Sleep(1000);
}
///<summary>
///使用打印機(jī)進(jìn)行打印
///</summary>
privatestaticvoidUsePrinter()
{
//臨界區(qū)
lock(UsingPrinterLocker)
{
Console.WriteLine("{0}acquiredthelock",Thread.CurrentThread.Name);
//模擬打印操作
Thread.Sleep(500);
Console.WriteLine("{0}exitinglock",Thread.CurrentThread.Name);
}
}

///<summary>
///使用打印機(jī)進(jìn)行打印
///</summary>
privatestaticvoidUsePrinterWithMonitor()
{
System.Threading.Monitor.Enter(UsingPrinterLocker);
try
{
Console.WriteLine("{0}acquiredthelock",Thread.CurrentThread.Name);
//模擬打印操作
Thread.Sleep(500);
Console.WriteLine("{0}exitinglock",Thread.CurrentThread.Name);
}
finally
{
System.Threading.Monitor.Exit(UsingPrinterLocker);
}
}

///<summary>
///使用打印機(jī)進(jìn)行打印
///</summary>
privatestaticvoidUsePrinterWithMutex()
{
mutex.WaitOne();
try
{
Console.WriteLine("{0}acquiredthelock",Thread.CurrentThread.Name);
//模擬打印操作
Thread.Sleep(500);
Console.WriteLine("{0}exitinglock",Thread.CurrentThread.Name);
}
finally
{
mutex.ReleaseMutex();
}
}
}
}

6、讀取器/編寫器鎖

ReaderWriterLockSlim類允許多個(gè)線程同時(shí)讀取一個(gè)資源，但在向該資源寫入時(shí)要求線程等待以獲得獨(dú)占鎖。

可以在應(yīng)用程序中使用ReaderWriterLockSlim，以便在訪問一個(gè)共享資源的線程之間提供協(xié)調(diào)同步。獲得的鎖是針對(duì)ReaderWriterLockSlim本身的。
設(shè)計(jì)您應(yīng)用程序的結(jié)構(gòu)，讓讀取和寫入操作的時(shí)間盡可能最短。因?yàn)閷懭腈i是排他的，所以長(zhǎng)時(shí)間的寫入操作會(huì)直接影響吞吐量。長(zhǎng)時(shí)間的讀取操作會(huì)阻止處于等待狀態(tài)的編寫器，并且，如果至少有一個(gè)線程在等待寫入訪問，則請(qǐng)求讀取訪問的線程也將被阻止。

案例：構(gòu)造一個(gè)線程安全的緩存

復(fù)制代碼代碼如下:

usingSystem;
usingSystem.Threading;
usingSystem.Collections.Generic;

namespaceMutiThreadSample.ThreadSynchronization
{
///<summary>
///同步Cache
///</summary>
publicclassSynchronizedCache
{
privateReaderWriterLockSlimcacheLock=newReaderWriterLockSlim();
privateDictionary<int,string>innerCache=newDictionary<int,string>();
///<summary>
///讀取
///</summary>
///<paramname="key"></param>
///<returns></returns>
publicstringRead(intkey)
{
cacheLock.EnterReadLock();
try
{
returninnerCache[key];
}
finally
{
cacheLock.ExitReadLock();
}
}
///<summary>
///添加項(xiàng)
///</summary>
///<paramname="key"></param>
///<paramname="value"></param>
publicvoidAdd(intkey,stringvalue)
{
cacheLock.EnterWriteLock();
try
{
innerCache.Add(key,value);
}
finally
{
cacheLock.ExitWriteLock();
}
}
///<summary>
///添加項(xiàng)，有超時(shí)限制
///</summary>
///<paramname="key"></param>
///<paramname="value"></param>
///<paramname="timeout"></param>
///<returns></returns>
publicboolAddWithTimeout(intkey,stringvalue,inttimeout)
{
if(cacheLock.TryEnterWriteLock(timeout))
{
try
{
innerCache.Add(key,value);
}
finally
{
cacheLock.ExitWriteLock();
}
returntrue;
}
else
{
returnfalse;
}
}
///<summary>
///添加或者更新
///</summary>
///<paramname="key"></param>
///<paramname="value"></param>
///<returns></returns>
publicAddOrUpdateStatusAddOrUpdate(intkey,stringvalue)
{
cacheLock.EnterUpgradeableReadLock();
try
{
stringresult=null;
if(innerCache.TryGetValue(key,outresult))
{
if(result==value)
{
returnAddOrUpdateStatus.Unchanged;
}
else
{
cacheLock.EnterWriteLock();
try
{
innerCache[key]=value;
}
finally
{
cacheLock.ExitWriteLock();
}
returnAddOrUpdateStatus.Updated;
}
}
else
{
cacheLock.EnterWriteLock();
try
{
innerCache.Add(key,value);
}
finally
{
cacheLock.ExitWriteLock();
}
returnAddOrUpdateStatus.Added;
}
}
finally
{
cacheLock.ExitUpgradeableReadLock();
}
}
///<summary>
///刪除項(xiàng)
///</summary>
///<paramname="key"></param>
publicvoidDelete(intkey)
{
cacheLock.EnterWriteLock();
try
{
innerCache.Remove(key);
}
finally
{
cacheLock.ExitWriteLock();
}
}
///<summary>
///
///</summary>
publicenumAddOrUpdateStatus
{
Added,
Updated,
Unchanged
};
}
}

7、Semaphore和SemaphoreSlim

System.Threading.Semaphore類表示一個(gè)命名（系統(tǒng)范圍）信號(hào)量或本地信號(hào)量。它是一個(gè)對(duì)Win32信號(hào)量對(duì)象的精簡(jiǎn)包裝。Win32信號(hào)量是計(jì)數(shù)信號(hào)量，可用于控制對(duì)資源池的訪問。
SemaphoreSlim類表示一個(gè)輕量的快速信號(hào)量，可用于在一個(gè)預(yù)計(jì)等待時(shí)間會(huì)非常短的進(jìn)程內(nèi)進(jìn)行等待。SemaphoreSlim會(huì)盡可能多地依賴由公共語言運(yùn)行時(shí)(CLR)提供的同步基元。但是，它也會(huì)根據(jù)需要提供延遲初始化的、基于內(nèi)核的等待句柄，以支持等待多個(gè)信號(hào)量。SemaphoreSlim還支持使用取消標(biāo)記，但它不支持命名信號(hào)量或使用等待句柄來進(jìn)行同步。

線程通過調(diào)用WaitOne方法來進(jìn)入信號(hào)量，此方法是從WaitHandle類派生的。當(dāng)調(diào)用返回時(shí)，信號(hào)量的計(jì)數(shù)將減少。當(dāng)一個(gè)線程請(qǐng)求項(xiàng)而計(jì)數(shù)為零時(shí)，該線程會(huì)被阻止。當(dāng)線程通過調(diào)用Release方法釋放信號(hào)量時(shí)，將允許被阻止的線程進(jìn)入。并不保證被阻塞的線程進(jìn)入信號(hào)量的順序，例如先進(jìn)先出(FIFO)或后進(jìn)先出(LIFO)。信號(hào)量的計(jì)數(shù)在每次線程進(jìn)入信號(hào)量時(shí)減小，在線程釋放信號(hào)量時(shí)增加。當(dāng)計(jì)數(shù)為零時(shí)，后面的請(qǐng)求將被阻塞，直到有其他線程釋放信號(hào)量。當(dāng)所有的線程都已釋放信號(hào)量時(shí)，計(jì)數(shù)達(dá)到創(chuàng)建信號(hào)量時(shí)所指定的最大值。

案例分析：購(gòu)買火車票

還得排隊(duì)進(jìn)行購(gòu)買，購(gòu)買窗口是有限的，只有窗口空閑時(shí)才能購(gòu)買

復(fù)制代碼代碼如下:

usingSystem;
usingSystem.Threading;

namespaceMutiThreadSample.ThreadSynchronization
{
///<summary>
///案例：支付流程
///如超市、藥店、火車票等，都有限定的幾個(gè)窗口進(jìn)行結(jié)算，只有有窗口空閑，才能進(jìn)行結(jié)算。
///我們就用多線程來模擬結(jié)算過程
///</summary>
classPaymentWithSemaphore
{
///<summary>
///聲明收銀員總數(shù)為3個(gè)，但是當(dāng)前空閑的個(gè)數(shù)為0，可能還沒開始上班。
///</summary>
privatestaticSemaphoreIdleCashiers=newSemaphore(0,3);
///<summary>
///測(cè)試支付過程
///</summary>
publicstaticvoidTestPay()
{
ParameterizedThreadStartstart=newParameterizedThreadStart(Pay);
//假設(shè)同時(shí)有5個(gè)人來買票
for(inti=0;i<5;i++)
{
Threadthread=newThread(start);
thread.Start(i);
}

//主線程等待，讓所有的的線程都激活
Thread.Sleep(1000);
//釋放信號(hào)量，2個(gè)收銀員開始上班了或者有兩個(gè)空閑出來了
IdleCashiers.Release(2);
}
///<summary>
///
///</summary>
///<paramname="obj"></param>
publicstaticvoidPay(objectobj)
{
Console.WriteLine("Thread{0}beginsandwaitsforthesemaphore.",obj);
IdleCashiers.WaitOne();
Console.WriteLine("Thread{0}startstoPay.",obj);
//結(jié)算
Thread.Sleep(2000);
Console.WriteLine("Thread{0}:Thepaymenthasbeenfinished.",obj);

Console.WriteLine("Thread{0}:Releasethesemaphore.",obj);
IdleCashiers.Release();
}
}
}

8、障礙（Barrier）4.0后技術(shù)

使多個(gè)任務(wù)能夠采用并行方式依據(jù)某種算法在多個(gè)階段中協(xié)同工作。
通過在一系列階段間移動(dòng)來協(xié)作完成一組任務(wù)，此時(shí)該組中的每個(gè)任務(wù)發(fā)信號(hào)指出它已經(jīng)到達(dá)指定階段的Barrier并且暗中等待其他任務(wù)到達(dá)。相同的Barrier可用于多個(gè)階段。

9、SpinLock(4.0后)
SpinLock結(jié)構(gòu)是一個(gè)低級(jí)別的互斥同步基元，它在等待獲取鎖時(shí)進(jìn)行旋轉(zhuǎn)。在多核計(jì)算機(jī)上，當(dāng)?shù)却龝r(shí)間預(yù)計(jì)較短且極少出現(xiàn)爭(zhēng)用情況時(shí)，SpinLock的性能將高于其他類型的鎖。不過，我們建議您僅在通過分析確定System.Threading.Monitor方法或Interlocked方法顯著降低了程序的性能時(shí)使用SpinLock。
即使SpinLock未獲取鎖，它也會(huì)產(chǎn)生線程的時(shí)間片。它這樣做是為了避免線程優(yōu)先級(jí)別反轉(zhuǎn)，并使垃圾回收器能夠繼續(xù)執(zhí)行。在使用SpinLock時(shí)，請(qǐng)確保任何線程持有鎖的時(shí)間不會(huì)超過一個(gè)非常短的時(shí)間段，并確保任何線程在持有鎖時(shí)不會(huì)阻塞。
由于SpinLock是一個(gè)值類型，因此，如果您希望兩個(gè)副本都引用同一個(gè)鎖，則必須通過引用顯式傳遞該鎖。

復(fù)制代碼代碼如下:

usingSystem;
usingSystem.Text;
usingSystem.Threading;
usingSystem.Threading.Tasks;

namespaceMutiThreadSample.ThreadSynchronization
{
classSpinLockSample
{
publicstaticvoidTest()
{
SpinLocksLock=newSpinLock();
StringBuildersb=newStringBuilder();
Actionaction=()=>
{
boolgotLock=false;
for(inti=0;i<100;i++)
{
gotLock=false;
try
{
sLock.Enter(refgotLock);
sb.Append(i.ToString());
}
finally
{
//真正獲取之后，才釋放
if(gotLock)sLock.Exit();
}
}
};

//多線程調(diào)用action
Parallel.Invoke(action,action,action);
Console.WriteLine("輸出：{0}",sb.ToString());
}
}
}

10、SpinWait(4.0后)

System.Threading.SpinWait是一個(gè)輕量同步類型，可以在低級(jí)別方案中使用它來避免內(nèi)核事件所需的高開銷的上下文切換和內(nèi)核轉(zhuǎn)換。在多核計(jì)算機(jī)上，當(dāng)預(yù)計(jì)資源不會(huì)保留很長(zhǎng)一段時(shí)間時(shí)，如果讓等待線程以用戶模式旋轉(zhuǎn)數(shù)十或數(shù)百個(gè)周期，然后重新嘗試獲取資源，則效率會(huì)更高。如果在旋轉(zhuǎn)后資源變?yōu)榭捎玫?，則可以節(jié)省數(shù)千個(gè)周期。如果資源仍然不可用，則只花費(fèi)了少量周期，并且仍然可以進(jìn)行基于內(nèi)核的等待。這一旋轉(zhuǎn)-等待的組合有時(shí)稱為“兩階段等待操作”。

下面的基本示例采用微軟案例：無鎖堆棧

復(fù)制代碼代碼如下:

usingSystem;
usingSystem.Threading;

namespaceMutiThreadSample.ThreadSynchronization
{
publicclassLockFreeStack<T>
{
privatevolatileNodem_head;

privateclassNode{publicNodeNext;publicTValue;}

publicvoidPush(Titem)
{
varspin=newSpinWait();
Nodenode=newNode{Value=item},head;
while(true)
{
head=m_head;
node.Next=head;
if(Interlocked.CompareExchange(refm_head,node,head)==head)break;
spin.SpinOnce();
}
}

publicboolTryPop(outTresult)
{
result=default(T);
varspin=newSpinWait();

Nodehead;
while(true)
{
head=m_head;
if(head==null)returnfalse;
if(Interlocked.CompareExchange(refm_head,head.Next,head)==head)
{
result=head.Value;
returntrue;
}
spin.SpinOnce();
}
}
}
}

總結(jié)：

盡管有這么多的技術(shù)，但是不同的技術(shù)對(duì)應(yīng)不同的場(chǎng)景，我們必須熟悉其特點(diǎn)和適用范圍。在應(yīng)用時(shí)，必須具體問題具體分析，選擇最佳的同步方式。

您可能感興趣的文章: