線程也瘋狂----線程同步（1）

前言

當線程池的線程阻塞時，線程池會建立額外的線程，而建立、銷燬和調度線程所須要至關昂貴的內存資源，另外，不少的開發人員看見本身程序的線程沒有作任何有用的事情時習慣建立更多的線程，爲了構建可伸縮、響應靈敏的程序，咱們在前面介紹了線程也瘋狂-----異步編程。

可是異步編程一樣也存在着很嚴重的問題，若是兩個不一樣的線程訪問相同的變量和數據，按照咱們異步函數的實現方式，不可能存在兩個線程同時訪問相同的數據，這個時候咱們就須要線程同步。多個線程同時訪問共享數據的時，線程同步能防止數據損壞，之因此強調同時這個概念，由於線程同步本質就是計時問題。

異步和同步是相對的，同步就是順序執行，執行完一個再執行下一個，須要等待、協調運行。異步就是彼此獨立,在等待某事件的過程當中繼續作本身的事，不須要等待這一事件完成後再工做。線程就是實現異步的一個方式。異步是讓調用方法的主線程不須要同步等待另外一線程的完成，從而可讓主線程幹其它的事情。

 

基元用戶模式和內核模式構造

基礎概念

基元：能夠在代碼中使用的簡單的構造

用戶模式：經過特殊的CPU指令協調線程，操做系統永遠檢測不到一個線程在基元用戶模式的構造上阻塞。

內核模式：由windows自身提供，在應用程序的線程中調用由內核實現的函數。

用戶模式構造

易變構造

 C#編譯器、JIT編譯器和CPU都會對代碼進行優化，它們儘可能保證保留咱們的意圖，可是從多線程的角度出發，咱們的意圖並不必定會獲得保留，下面舉例說明：

 1  static void Main(string[] args)
 2         {
 3            Console.WriteLine("讓worker函數運行5s後中止");
 4            var t = new Thread(Worker);
 5             t.Start();
 6             Thread.Sleep(5000);
 7             stop = true;
 8 
 9             Console.ReadLine();
10         }
11 
12         private static bool stop = false;
13 
14         private static void Worker(object obj)
15         {
16             int x = 0;
17             while (!stop)
18             {
19                 x++;
20             }
21             Console.WriteLine("worker函數中止x=｛0｝",x);
22         }

編譯器若是檢查到stop爲false，就生成代碼來進入一個無限循環，並在循環中一直遞增x，因此優化循環很快完成，可是編譯器只檢測stop一次，並非每次都會檢測。

例子2---兩個線程同時訪問：

 1 class test
 2     {
 3         private static int m_flag = 0;
 4 
 5         private static int m_value = 0;
 6 
 7         public static void Thread1(object obj)
 8         {
 9             m_value = 5;
10             m_flag = 1;
11 
12         }
13 
14         public static void Thread2(object obj)
15         {
16             if (m_flag == 1)
17                 Console.WriteLine("m_value = {0}", m_value);
18         }
19 
20         //多核CPU機器纔會出現線程同步問題
21         public void Exec()
22         {
23             var thread1 = new Thread(Thread1);
24             var thread2 = new Thread(Thread2);
25             thread1.Start();
26             thread2.Start();
27             Console.ReadLine();
28         }
29     }

程序在執行的時候，編譯器必須將變量m_flag和m_value從RAM讀入CPU寄存器，RAM先傳遞m_value的值0，thread1把值變爲5，可是thread2並不知道thread2仍然認爲值爲0,這種問題通常來講發生在多核CPU的機率大一些，應該CPU越多，多個線程同時訪問資源的概率就越大。

關鍵字volatile，做用禁止C#編譯器、JTP編譯器和CPU執行的一些優化，若是作用於變量後，將不容許字段緩存到CPU的寄存器中，確保字段的讀寫都在RAM中進行。

 

互鎖構造

System.Threading.Interlocked類中的每一個方法都執行一次原子的讀取以及寫入操做，調用某個Interlocked方法以前的任何變量寫入都在這個Interlocked方法調用以前執行，而調用以後的任何變量讀取都在這個調用以後讀取。

Interlocked方法主要是對INT32變量進行靜態操做Add、Decrement、Compare、Exchange、CompareChange等方法，也接受object、Double等類型的參數。

原子操做：是指不會被線程調度機制打斷的操做；這種操做一旦開始，就一直運行到結束，中間不會有任何 context switch （切換到另外一個線程）。

代碼演示：

說明：經過Interlocked的方法異步查詢幾個web服務器，並同時返回數據，且結果只執行一次。

//上報狀態類型
    enum CoordinationStatus
    {
        Cancel,
        Timeout,
        AllDone
    }

 1  class AsyncCoordinator
 2     {
 3         //AllBegun 內部調用JustEnded來遞減它
 4         private int _mOpCount = 1;
 5 
 6         //0=false,1=true
 7         private int _mStatusReported = 0;
 8 
 9         private Action<CoordinationStatus> _mCallback;
10 
11         private Timer _mTimer;
12 
13         //發起一個操做以前調用
14         public void AboutToBegin(int opsToAdd = 1)
15         {
16            Interlocked.Add(ref _mOpCount, opsToAdd);
17         }
18 
19         //處理好一個操做的結果以後調用
20         public void JustEnded()
21         {
22             if (Interlocked.Decrement(ref _mOpCount) == 0)
23             {
24                 ReportStatus(CoordinationStatus.AllDone);
25             }        
26         }
27 
28         //該方法必須在發起全部操做後調用
29         public void AllBegin(Action<CoordinationStatus> callback, int timeout = Timeout.Infinite)
30         {
31             _mCallback = callback;
32             if (timeout != Timeout.Infinite)
33             {
34                 _mTimer = new Timer(TimeExpired, null, timeout, Timeout.Infinite);
35                 JustEnded();
36             }
37         }
38 
39         private void TimeExpired(object o)
40         {
41             ReportStatus(CoordinationStatus.Timeout);
42         }
43 
44         public void Cancel()
45         {
46             ReportStatus(CoordinationStatus.Cancel);
47         }
48 
49         private void ReportStatus(CoordinationStatus status)
50         {
51             //若是狀態從未報告過，就報告它，不然就忽略它，只調用一次
52             if (Interlocked.Exchange(ref _mStatusReported, 1) == 0)
53             {
54                 _mCallback(status);
55             }         
56         }
57     }

 1 class MultiWebRequest
 2     {
 3         //輔助類 用於協調全部的異步操做
 4         private AsyncCoordinator _mac = new AsyncCoordinator();
 5 
 6         protected Dictionary<string,object> _mServers = new Dictionary<string, object>
 7         {
 8             {"http://www.baidu.com",null},{"http://www.Microsoft.com",null},{"http://www.cctv.com",null},
 9             {"http://www.souhu.com",null},{"http://www.sina.com",null},{"http://www.tencent.com",null},
10             {"http://www.youku.com",null}
11         };
12 
13         private Stopwatch sp;
14         public MultiWebRequest(int timeout = Timeout.Infinite)
15         {
16             sp = new Stopwatch();
17             sp.Start();
18             //經過異步方式一次性發起請求
19             var httpclient = new HttpClient();
20 
21             foreach (var server in _mServers.Keys)
22             {
23                 _mac.AboutToBegin(1);
24 
25                 httpclient.GetByteArrayAsync(server).ContinueWith(task => ComputeResult(server, task));
26             }
27             _mac.AllBegin(AllDone,timeout);
28             Console.WriteLine("");
29         }
30 
31         private void ComputeResult(string server, Task<Byte[]> task)
32         {
33             object result;
34             if (task.Exception != null)
35             {
36                 result = task.Exception.InnerException;
37             }
38             else
39             {
40                 //線程池處理IO
41                 result = task.Result.Length;
42             }
43 
44             //保存返回結果的長度
45             _mServers[server] = result;
46 
47             _mac.JustEnded();
48         }
49 
50         public void Cancel()
51         {
52             _mac.Cancel();
53         }
54 
55         private void AllDone(CoordinationStatus status)
56         {
57             sp.Stop();
58             Console.WriteLine("響應耗時總計{0}",sp.Elapsed);
59             switch (status)
60             {
61                 case CoordinationStatus.Cancel:
62                     Console.WriteLine("操做取消");
63                     break;
64                 case CoordinationStatus.AllDone:
65                     Console.WriteLine("操做完成，完成的結果以下");
66                     foreach (var server in _mServers)
67                     {
68                         Console.WriteLine("{0}",server.Key);
69                         object result = server.Value;
70                         if (result is Exception)
71                         {
72                             Console.WriteLine("錯誤緣由{0}",result.GetType().Name);
73                         }
74                         else
75                         {
76                             Console.WriteLine("返回字節數爲：{0}",result);
77                         }
78                     }
79                     break;
80                 case CoordinationStatus.Timeout:
81                     Console.WriteLine("操做超時");
82                     break;
83                 default:
84                     throw new ArgumentOutOfRangeException("status", status, null);
85             }
86         }
87     }

很是建議你們參考一下以上代碼，我在對服務器進行訪問時，也會經常參考這個模型。

簡單的自旋鎖

 1 class SomeResource
 2     {
 3          private SimpleSpinLock s1 = new SimpleSpinLock();
 4 
 5         public void AccessResource()
 6         {
 7             s1.Enter();
 8             //一次是有一個線程才能進入訪問
 9             s1.Leave();
10 
11         }
12     }
13 
14     class SimpleSpinLock
15     {
16         private int _mResourceInUse;
17 
18         public void Enter()
19         {
20             while (true)
21             {
22                 if(Interlocked.Exchange(ref _mResourceInUse,1)==0)
23                     return;
24             }
25         }
26 
27         public void Leave()
28         {
29             Volatile.Write(ref _mResourceInUse,1);
30         }
31     }

這就是一個線程同步鎖的簡單實現，這種鎖的最大問題在於，存在競爭的狀況下會形成線程的「自旋」，這會浪費CPU的寶貴時間，組織CPU作更多的工做，所以，這種自旋鎖應該用於保護那些執行的很是快的代碼。

 

下篇咱們將繼續講解線程同步，內核模式構造和混合線程同步構造，但願這些內容能夠幫助到你們一塊兒成長，若是發現博客有什麼錯誤請及時提出寶貴意見，以避免形成誤導！