本筆記摘抄自：https://www.cnblogs.com/zhili/archive/2012/07/21/ThreadsSynchronous.html，記錄一下學習過程以備後續查用。
一、線程同步概述
創建多線程來實現讓我們能夠更好地響應應用程序，然而當我們創建了多個線程時，就存在多個線程同時訪問一個共享資源的情況。此時，我們就需要用到線程同步。線程同
步可以防止數據（共享資源）的損壞。
一般來說，設計應用程序應儘量避免使用線程同步， 因爲線程同步會產生一些問題：
1.1、它的使用比較繁瑣。我們需要用額外的代碼，把多個線程同時訪問的數據包圍起來，並獲取和釋放一個線程同步鎖。如果有一個代碼塊忘記獲取鎖，就有可能造成數據損壞。
1.2、使用線程同步會影響性能。
1.2.1、獲取和釋放一個鎖是需要時間的，我們在決定哪個線程先獲取鎖的時候，CPU要進行協調，這些額外的工作就會對性能造成影響。
1.2.2、線程同步一次只允許一個線程訪問資源，這樣就會阻塞線程，而阻塞線程會造成更多的線程被創建。這樣CPU就有可能要調度更多的線程，從而對性能造成影響。
二、線程同步使用
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();
}
}運行結果如下：
