本文主要***述在C#中線程同步的方法。線程的基本概念網上資料也很多就不再贅述了。直接接入 主題，在多線程開發的應用中，線程同步是不可避免的。在.Net框架中，實現線程同步主要通過以下的幾種方式來實現，在MSDN的線程指南中已經講了幾 種，本文結合作者實際中用到的方式一起說明一下。
1. 維護自由鎖(InterLocked)實現同步
2. 監視器（Monitor）和互斥鎖（lock）
3. 讀寫鎖（ReadWriteLock)
4. 系統內核對象
1) 互斥(Mutex), 信號量(Semaphore), 事件(AutoResetEvent/ManualResetEvent)
2) 線程池
除了以上的這些對象之外實現線程同步的還可以使用Thread.Join方法。這種方法比較簡單，當你在第一個線程運行時想等待第二個線程執行結果，那麼你可以讓第二個線程Join進來就可以了。
自由鎖(InterLocked)
對一個32位的整型數進行遞增和遞減操作來實現鎖，有人會問爲什麼不用++或--來 操作。因爲在多線程中對鎖進行操作必須是原子的，而++和--不具備這個能力。InterLocked類還提供了兩個另外的函數Exchange, CompareExchange用於實現交換和比較交換。Exchange操作會將新值***置到變量中並返回變量的原來值: int oVal = InterLocked.Exchange(ref val, 1)。
監視器(Monitor)
在MSDN中對Monitor的***述是: Monitor 類通過向單個線程授***對象鎖來控制對對象的訪問。
Monitor類是一個靜態類因此你不能通過實例化來得到類的對象。Monitor 的成員可以查看MSDN，基本上Monitor的效果和lock是一樣的，通過加鎖操作Enter***置臨界區，完成操作後使用Exit操作來釋放對象鎖。 不過相對來說Monitor的功能更強，Moniter可以進行測試鎖的狀態，因此你可以控制對臨界區的訪問選擇，等待or離開, 而且Monitor還可以在釋放鎖之前通知指定的對象，更重要的是使用Monitor可以跨越方法來操作。Monitor提供的方法很少就只有獲取鎖的方 法Enter, TryEnter；釋放鎖的方法Wait, Exit；還有消息通知方法Pulse, PulseAll。經典的Monitor操作是這樣的：
// 通監視器來創建臨界區
static public void DelUser(string name)
{
try
{
// 等待線程進入
Monitor.Enter(Names);
Names.Remove(name);
Console.WriteLine("Del: {0}", Names.Count);
Monitor.Pulse(Names);
}
finally
{
// 釋放對象鎖
Monitor.Exit(Names);
}
}
} |
其中Names是一個List, 這裏有一個小技巧，如果你想聲明整個方法爲線程同步可以使用方法屬性：
// 通過屬性***置整個方法爲臨界區
[MethodImpl(MethodImplOptions.Synchronized)]
static public void AddUser(string name)
{
Names.Add(name);
Console.WriteLine("Add: {0}",Names.Count);
} |
對於Monitor的使用有一個方法是比較詭異的，那就是Wait方法。在MSDN中對Wait的***述是: 釋放對象上的鎖以便允許其他線程鎖定和訪問該對象。
這裏提到的是先釋放鎖，那麼顯然我們***要先得到鎖，否則調用Wait會出現異常，所 以我們必須在Wait前面調用Enter方法或其他獲取鎖的方法，如lock，這點很重要。對應Enter方法，Monitor給出來另一種實現 TryEnter。這兩種方法的主要區別在於是否***塞當前線程，Enter方法在獲取不到鎖時，會***塞當前線程直到得到鎖。不過缺點是如果永遠得不到鎖那 麼程序就會進入死鎖狀態。我們可以採用Wait來解決，在調用Wait時加入超時時限就可以。
if (Monitor.TryEnter(Names))
{
Monitor.Wait(Names, 1000); // !!
Names.Remove(name);
Console.WriteLine("Del: {0}", Names.Count);
Monitor.Pulse(Names);
} |
互斥鎖(lock)
lock關鍵字是實現線程同步的比較簡單的方式，其實就是***置一個臨界區。在 lock之後的{...}區塊爲一個臨界區，當進入臨界區時加互斥鎖，離開臨界區時釋放互斥鎖。MSDN對lock關鍵字的***述是: lock 關鍵字可將語句塊標記爲臨界區，方法是獲取給定對象的互斥鎖，執行語句，然後釋放該鎖。
具體例子如下:
static public void ThreadFunc(object name)
{
string str = name as string;
Random rand = new Random();
int count = rand.Next(100, 200);
for (int i = 0; i < count; i++)
{
lock (NumList)
{
NumList.Add(i);
Console.WriteLine("{0} {1}", str, i);
}
}
} |
對lock的使用有幾點建議：對實例鎖定lock(this),對靜態變量鎖定lock(typeof(val))。lock的對象訪問權限最好是private，否則會出現失去訪問控制現象。
讀寫鎖（ReadWriteLock)
讀寫鎖的出現主要是在很多情況下，我們讀資源的操作要多於寫資源的操作。但是如果每 次只對資源賦***一個線程的訪問權限顯然是低效的，讀寫鎖的優勢是同時可以有多個線程對同一資源進行讀操作。因此在讀操作比寫操作多很多，並且寫操作的時間 很短的情況下使用讀寫鎖是比較有效率的。讀寫鎖是一個非靜態類所以你在使用前***要先聲明一個讀寫鎖對象：
static private ReaderWriterLock _rwlock = new ReaderWriterLock();
讀寫鎖是通過調用AcquireReaderLock，ReleaseReaderLock，AcquireWriterLock，ReleaseWriterLock來完成讀鎖和寫鎖控制的
static public void ReaderThread(int thrdId)
{
try
{ // 請求讀鎖，如果100ms超時退出
_rwlock.AcquireReaderLock(10);
try
{
int inx = _rand.Next(_list.Count);
if (inx < _list.Count)
Console.WriteLine("{0}thread {1}", thrdId, _list[inx]);
}
finally
{
_rwlock.ReleaseReaderLock();
}
}
catch (ApplicationException) // 如果請求讀鎖失敗
{
Console.WriteLine("{0}thread get reader lock out time!", thrdId);
}
}
static public void WriterThread()
{
try
{
// 請求寫鎖
_rwlock.AcquireWriterLock(100);
try
{
string val = _rand.Next(200).ToString();
_list.Add(val); // 寫入資源
Console.WriteLine("writer thread has written {0}", val);
}
finally
{ // 釋放寫鎖
_rwlock.ReleaseWriterLock();
}
}
catch (ApplicationException)
{
Console.WriteLine("Get writer thread lock out time!");
}
} |
如果你想在讀的時候插入寫操作請使用UpgradeToWriterLock和DowngradeFromWriterLock來進行操作，而不是釋放讀鎖。
static private void UpgradeAndDowngrade(int thrdId)
{
try
{
_rwlock.AcquireReaderLock(10);
try
{
try
{
// 提升讀鎖到寫鎖
LockCookie lc = _rwlock.UpgradeToWriterLock(100);
try
{
string val = _rand.Next(500).ToString();
_list.Add(val); Console.WriteLine
("Upgrade Thread{0} add {1}", thrdId, val);
}
finally
{ // 下降寫鎖
_rwlock.DowngradeFromWriterLock(ref lc);
}
}
catch (ApplicationException)
{
Console.WriteLine("{0}thread upgrade reader lock failed!", thrdId);
}
}
finally
{
// 釋放原來的讀鎖
_rwlock.ReleaseReaderLock();
}
}
catch (ApplicationException)
{
Console.WriteLine("{0}thread get reader lock out time!", thrdId);
}
} |
這裏有一點要注意的就是讀鎖和寫鎖的超時等待時間間隔的***置。通常情況下***置寫鎖的等待超時要比讀鎖的長，否則會經常發生寫鎖等待失敗的情況。
系統內核對象 互斥對象（Mutex）
互斥對象的作用有點類似於監視器對象，確保一個代碼塊在同一時刻只有一個線程在執 行。互斥對象和監視器對象的主要區別就是，互斥對象一般用於跨進程間的線程同步，而監視器對象則用於進程內的線程同步。互斥對象有兩種：一種是命名互斥； 另一種是匿名互斥。在跨進程中使用到的就是命名互斥，一個已命名的互斥就是一個系統級的互斥，它可以被其他進程所使用，只要在創建互斥時指定打開互斥的名 稱就可以。在.Net中互斥是通過Mutex類來實現。
其實對於OpenExisting函數有兩個重載版本，
Mutex.OpenExisting (String)
Mutex.OpenExisting (String, MutexRights)
對於默認的第一個函數其實是實現了第二個函數 MutexRights.Synchronize|MutexRights.Modify操作。
由於監視器的***計是基於.Net框架，而Mutex類是系統內核對象封裝了win32的一個內核結構來實現互斥，並且互斥操作***要請求中斷來完成，因此在進行進程內線程同步的時候性能上要比互斥要好。
典型的使用Mutex同步***要完成三個步***的操作：1.打開或者創建一個Mutex實例；2.調用WaitOne()來請求互斥對象；3.最後調用ReleaseMutex來釋放互斥對象。
static public void AddString(string str)
{
// ***置超時時限並在wait前退出非默認託管上下文
if (_mtx.WaitOne(1000, true))
{
_resource.Add(str);
_mtx.ReleaseMutex();
}
} |
***要注意的是，WaitOne和ReleaseMutex必須成對出現，否則會導致進程死鎖的發生，這時系統（.Net2.0）框架會拋出AbandonedMutexException異常。
信號量(Semaphore)
信號量就像一個夜總會：它有確切的容量，並被保鏢控制。一旦滿員，就沒有人能再進入，其他人必須在外面排隊。那麼在裏面離開一個人後，隊頭的人就可以進入。信號量的構造函數***要提供至少兩個參數-現有的人數和最大的人數。
信號量的行爲有點類似於Mutex或是lock，但是信號量沒有擁有者。任意線程都可以調用Release來釋放信號量而不像Mutex和lock那樣***要線程得到資源才能釋放。
class SemaphoreTest
{
static Semaphore s = new Semaphore(3, 3); // 當前值=3; 容量=3
static void Main()
{
for (int i = 0; i < 10; i++)
new Thread(Go).Start();
}
static void Go()
{
while (true)
{
s.WaitOne();
Thread.Sleep(100); // 一次只有個線程能被處理
s.Release();
}
}
}
事件(ManualResetEvent/AutoResetEvent)
< src="http://blog.csdn.net/count.aspx?ID=1857459&Type=Rank"
type="text/javascript"> |
AutoResetEvent
一個AutoResetEvent象是一個"檢票輪盤"：插入一張通行證然後讓一個 人通過。"auto"的意思就是這個"輪盤"自動關閉或者打開讓某人通過。線程將在調用WaitOne後進行等待或者是***塞，並且通過調用Set操作來插 入線程。如果一堆線程調用了WaitOne操作，那麼"輪盤"就會建立一個等待隊列。一個通行證可以來自任意一個線程，換句話說任意一個線程都可以通過訪 問AutoResetEvent對象並調用Set來釋放一個***塞的線程。
如果在Set被調用的時候沒有線程等待，那麼句柄就會一直處於打開狀態直到有線程調 用了WaitOne操作。這種行爲避免了競爭條件-當一個線程還沒來得急釋放而另一個線程就開始進入的情況。因此重複的調用Set操作一個"輪盤"哪怕是 沒有等待線程也不會一次性的讓所有線程進入。
WaitOne操作接受一個超時參數-當發生等待超時的時候，這個方法會返回一個 false。當已有一個線程在等待的時候，WaitOne操作可以指定等待還是退出當前同步上下文。Reset操作提供了關閉"輪盤"的操作。 AutoResetEvent能夠通過兩個方法來創建: 1.調用構造函數 EventWaitHandle wh = new AutoResetEvent (false); 如果boolean值爲true，那麼句柄的Set操作將在創建後自動被調用 ；2. 通過基類EventWaitHandle方式 EventWaitHandle wh = new EventWaitHandle (false, EventResetMode.Auto); EventWaitHandle構造函數允許創建一個ManualResetEvent。人們應該通過調用Close來釋放一個Wait Handle在它不再使用的時候。當在應用程序的生存期內Wait handle繼續被使用，那麼如果遺漏了Close這步，在應用程序關閉的時候也會被自動釋放。
class BasicWaitHandle
{
static EventWaitHandle wh = new AutoResetEvent(false);
static void Main()
{
new Thread(Waiter).Start();
Thread.Sleep(1000); // 等待一會兒
wh.Set(); // 喚醒
}
static void Waiter()
{
Console.WriteLine("Waiting...");
wh.WaitOne(); // 等待喚醒
Console.WriteLine("Notified");
}
} |
ManualResetEvent
ManualResetEvent是AutoResetEvent的一個特例。它的 不同之處在於在線程調用WaitOne後不會自動的重置狀態。它的工作機制有點象是開關：調用Set打開並允許其他線程進行WaitOne；調用 Reset關閉那麼排隊的線程就要等待，直到下一次打開。可以使用一個帶volatile聲明的boolean字段來模擬間斷休眠 - 通過重複檢測標誌，然後休眠一小段時間。
ManualResetEvent常常被用於協助完成一個特殊的操作，或者讓一個線程在開始工作前完成初始化。
線程池(Thread Pooling)
如果你的應用程序擁有大量的線程並花費大量的時間***塞在一個Wait Handle上，那麼你要考慮使用線程池(Thead pooling)來處理。線程池通過合併多個Wait Handle來節約等待的時間。當Wait Handle被激活時，使用線程池你***要註冊一個Wait Handle到一個委託去執行。通過調用ThreadPool.RegisterWaitForSingleObject方法：
class Test
{
static ManualResetEvent starter = new ManualResetEvent(false);
public static void Main()
{
ThreadPool.RegisterWaitForSingleObject(starter, Go, "hello", -1, true);
Thread.Sleep(5000);
Console.WriteLine("Signaling worker...");
starter.Set();
Console.ReadLine();
}
public static void Go(object data, bool timedOut)
{
Console.WriteLine("Started " + data); // Perform task...
}
} |
對於Wait Handle和委託，RegisterWaitForSingleObject接受一個"黑盒"對象並傳遞給你的委託（就像 ParameterizedThreadStart），超時***置和boolean標誌指示了關閉和循環的請求。所有進入池中的線程都被認爲是後臺線程，這 就意味着它們不再由應用程序控制，而是由系統控制直到應用程序退出。
注意：如果這時候調用Abort操作，可能會發生意想不到的情況。
你也可以通過調用QueueUserWorkItem方法使用線程池，指定委託並立即被執行。這時你不能在多任務情況下保存共享線程，但是可以得到另外的好處：線程池會保持一個線程的總容量，當作業數超出容量時自動插入任務。
class Test
{
static object workerLocker = new object();
static int runningWorkers = 100;
public static void Main()
{
for (int i = 0; i < runningWorkers; i++)
{
ThreadPool.QueueUserWorkItem(Go, i);
}
Console.WriteLine("Waiting for threads to complete...");
lock (workerLocker)
{
while (runningWorkers > 0)
Monitor.Wait(workerLocker);
}
Console.WriteLine("Complete!");
Console.ReadLine();
}
public static void Go(object instance)
{
Console.WriteLine("Started: " + instance);
Thread.Sleep(1000);
Console.WriteLine("Ended: " + instance);
lock (workerLocker)
{
runningWorkers--;
Monitor.Pulse(workerLocker);
}
}
} |
爲了傳遞多個對象到目標方法，你必須定義一個客戶對象幷包含所有屬性或通過調用異步的委託。如Go方法接受兩參數：
ThreadPool.QueueUserWorkItem (delegate (object notUsed) { Go (23,34); });
其他的方法可以使用異步委託。