本筆記摘抄自：https://www.cnblogs.com/zhili/archive/2012/07/21/ThreadsSynchronous.html，記錄一下學習過程以備後續查用。html
1、線程同步概述多線程
建立多線程來實現讓咱們可以更好地響應應用程序，然而當咱們建立了多個線程時，就存在多個線程同時訪問一個共享資源的狀況。此時，咱們就須要用到線程同步。線程同併發
步能夠防止數據（共享資源）的損壞。dom
通常來講，設計應用程序應儘可能避免使用線程同步， 由於線程同步會產生一些問題：性能
1.一、它的使用比較繁瑣。咱們須要用額外的代碼，把多個線程同時訪問的數據包圍起來，並獲取和釋放一個線程同步鎖。若是有一個代碼塊忘記獲取鎖，就有可能形成數據損壞。學習
1.二、使用線程同步會影響性能。ui
1.2.一、獲取和釋放一個鎖是須要時間的，咱們在決定哪一個線程先獲取鎖的時候，CPU要進行協調，這些額外的工做就會對性能形成影響。url
1.2.二、線程同步一次只容許一個線程訪問資源，這樣就會阻塞線程，而阻塞線程會形成更多的線程被建立。這樣CPU就有可能要調度更多的線程，從而對性能形成影響。 spa
2、線程同步使用.net
2.1 使用鎖對性能的影響
1.2.1描述過使用鎖會對性能產生影響，下面經過比較使用鎖和不使用鎖消耗的時間來講明這點：
class Program { static void Main(string[] args) { #region 線程同步：使用與不使用鎖的耗時對比 int x = 0; //迭代500萬次 const int iterationNumber = 5000000; //不使用鎖 Stopwatch sw = Stopwatch.StartNew(); for (int i = 0; i < iterationNumber; i++) { x++; } Console.WriteLine("Total time consuming is:{0}ms.", sw.ElapsedMilliseconds); sw.Restart(); //使用鎖 for (int i = 0; i < iterationNumber; i++) { Interlocked.Increment(ref x); } Console.WriteLine("Total time consuming is:{0}ms.", sw.ElapsedMilliseconds); Console.Read(); #endregion } }
運行結果以下：
2.2 Interlocked實現線程同步
Interlocked爲多個線程共享變量提供了原子操做，當咱們在多線程中對一個整數進行遞增操做時，就須要實現線程同步。
下面代碼演示加鎖與不加鎖的區別：
不加鎖：
class Program { //共享資源 public static int number = 0; static void Main(string[] args) { #region 線程同步：使用Interlocked實現線程同步 //不加鎖 for (int i = 0; i < 10; i++) { Thread thread = new Thread(Add); thread.Start(); } Console.Read(); #endregion } /// <summary> /// 遞增不加鎖 /// </summary> public static void Add() { Thread.Sleep(1000); Console.WriteLine("The current value of number is:{0}", ++number); } }
運行結果以下：
結果與預期可能不太同樣。爲了解決這樣的問題，咱們能夠經過使用 Interlocked.Increment方法來實現自增操做。
實現原理：相似銀行叫號，當有空號且號碼是本身的，才能去辦理相關的業務，不然繼續等待。
加鎖：
class Program { //共享資源 public static int number = 0; public static long signal = 0; static void Main(string[] args) { #region 線程同步：使用Interlocked實現線程同步 //加鎖 for (int i = 0; i < 10; i++) { Thread thread = new Thread(new ParameterizedThreadStart(AddWithInterlocked)); thread.Start(i); } Console.Read(); #endregion } /// <summary> /// 遞增長Interlocked鎖 /// </summary> public static void AddWithInterlocked(object parameter) { while (Interlocked.Read(ref signal) != 0 || (int)parameter != number) { Thread.Sleep(100); } Interlocked.Increment(ref signal); Console.WriteLine("The current value of number is:{0}", ++number); Interlocked.Decrement(ref signal); } }
運行結果以下：
2.3 Monitor實現線程同步
對於上面那個狀況，也能夠經過Monitor.Enter和Monitor.Exit方法來實現線程同步。
C#中經過lock關鍵字來提供簡化的語法(lock能夠理解爲Monitor.Enter和Monitor.Exit方法的語法糖)。
class Program { //共享資源 public static int number = 0; private static readonly object addLock = new object(); static void Main(string[] args) { #region 線程同步：使用Monitor實現線程同步 //非語法糖 for (int i = 0; i < 10; i++) { Thread thread = new Thread(AddWithMonitor); thread.Start(); } Console.Read(); //語法糖 //for (int i = 0; i < 10; i++) //{ // Thread thread = new Thread(AddWithLock); // thread.Start(); //} //Console.Read(); #endregion } /// <summary> /// 遞增長Monitor鎖 /// </summary> public static void AddWithMonitor() { Thread.Sleep(100); Monitor.Enter(addLock); Console.WriteLine("The current value of number is:{0}", ++number); Monitor.Exit(addLock); } /// <summary> /// 遞增長Lock鎖 /// </summary> public static void AddWithLock() { Thread.Sleep(100); lock (addLock) { Console.WriteLine("The current value of number is:{0}", ++number); } } }
運行結果以下：
接上面的addLock鎖(如下描述爲obj鎖)，順便學習一下Monitor類的原理：
Monitor在鎖對象obj上會維持兩個線程隊列R和W以及一個引用T ：
(1)T是對當前得到了obj鎖的線程的引用。
(2) R爲就緒隊列。
R隊列上的線程，是已經準備好了去競爭獲取obj鎖的線程。
線程可經過調用Monitor.Enter(obj)或Monitor.TryEnter(obj)而直接進入R隊列，可經過調用Monitor.Exit(obj)或Monitor.Wait(obj)釋放其所得到的obj鎖。
當obj鎖被某個線程釋放後，這個隊列上的線程就會去競爭obj鎖，而得到obj鎖的線程將被T引用。
(3) W爲等待隊列。
W隊列上的線程，是不會被OS直接調度執行的線程。也就是說，等待隊列上的線程不能去得到obj鎖。
線程可經過調用Monitor.Wait(obj)而直接進入W隊列，可經過調用Monitor.Pulse(obj)或Monitor.PulseAll(obj)將W隊列中的第一個等待線程或全部等待線程移至R隊列，
這時被移至R隊列的這些線程就有機會被OS直接調度執行，也就是能夠去競爭obj鎖。
(4)Monitor的成員方法。
Monitor.Enter(obj)/Monitor.TryEnter(obj) ：線程會進入R隊列以等待獲取obj鎖
Monitor.Exit(obj) ：線程釋放obj鎖（只有獲取了obj鎖的線程才能執行Monitor.Exit(obj)）
Monitor.Wait(obj)： 線程釋放當前得到的obj鎖，而後進入W隊列並阻塞。
Monitor.Pulse(obj) ：將W隊列中的第一個等待線程移至R隊列中以使第一個線程有機會獲取obj鎖。
Monitor.PulseAll(obj)：將W隊列中的全部等待線程移至R隊列以使得這些線程有機會得到obj鎖。
下面代碼演示Monitor.Wait及Monitor.Pulse的使用：
class Program { //共享資源 private static readonly object addLock = new object(); static void Main(string[] args) { #region 線程同步：Monitor.Wait與Monitor.Pulse的使用 for (int i = 0; i < 10; i++) { Thread thread = new Thread(MonitorWaitAndPulse); thread.Start(); } Console.Read(); #endregion } /// <summary> /// Monitor中的Wait與Pulse方法 /// </summary> public static void MonitorWaitAndPulse() { //進入就緒隊列等待獲取鎖資源 Monitor.Enter(addLock); //進來打聲招呼 Console.WriteLine("{0}：我來了，臨時要出去辦一下事。", Thread.CurrentThread.ManagedThreadId); //喚醒等待隊列中的第一個線程進入就緒隊列 Monitor.Pulse(addLock); //暫時釋放鎖資源進入等待隊列 Monitor.Wait(addLock); //出去辦事 Thread.Sleep(1000); //回來打聲招呼 Console.WriteLine("{0}：我回來了。", Thread.CurrentThread.ManagedThreadId); //釋放鎖資源 Monitor.Exit(addLock); } }
運行結果以下：
2.4 ReaderWriterLock實現線程同步
若是咱們須要對一個共享資源執行屢次讀取時，用前面所講的類實現的同步鎖都僅容許一個線程進行訪問，而其它線程將被阻塞。因爲只是進行讀取操做，實際上是沒有必要
堵塞其餘的線程， 應該讓它們併發的執行。
此時，可經過ReaderWriterLock類來實現並行讀取。
class Program { //建立對象 public static List<int> lists = new List<int>(); public static ReaderWriterLock readerWriteLock = new ReaderWriterLock(); static void Main(string[] args) { #region 線程同步：使用ReaderWriterLock實現線程同步 //建立一個線程讀取數據 Thread threadWrite = new Thread(Write); threadWrite.Start(); //建立10個線程讀取數據 for (int i = 0; i < 10; i++) { Thread threadRead = new Thread(Read); threadRead.Start(); } Console.Read(); #endregion } /// <summary> /// 寫入方法 /// </summary> public static void Write() { //獲取寫入鎖，以10毫秒爲超時。 readerWriteLock.AcquireWriterLock(10); Random ran = new Random(); int count = ran.Next(1, 10); lists.Add(count); Console.WriteLine("Write the data is:" + count); //釋放寫入鎖 readerWriteLock.ReleaseWriterLock(); } /// <summary> /// 讀取方法 /// </summary> public static void Read() { Thread.Sleep(100); //獲取讀取鎖 readerWriteLock.AcquireReaderLock(10); foreach (int list in lists) { //輸出讀取的數據 Console.WriteLine(list); } // 釋放讀取鎖 readerWriteLock.ReleaseReaderLock(); } }
運行結果以下：