C# 併發程式設計

K戰神發表於2019-04-28
C#程式設計

前言

對於現在很多程式語言來說，多執行緒已經得到了很好的支援，

以至於我們寫多執行緒程式簡單，但是一旦遇到併發產生的問題就會各種嘗試。

因為不是明白為什麼會產生併發問題，併發問題的根本原因是什麼。

接下來就讓我們來走近一點併發產生的那些問題。

猜猜是多少？

 public class ThreadTest_V0
    {
        public int count = 0;
        public void Add1()
        {
            int index = 0;
            while (index++ < 1000000)//100萬次
            {
                ++count;
            }
        }

        public void Add2()
        {
            int index = 0;
            while (index++ < 1000000)//100萬次
            {
                count++;
            }
        }
    }

結果是多少？

static void V0()
        {
            ThreadTest_V0 testV0 = new ThreadTest_V0();
            Thread th1 = new Thread(testV0.Add1);
            Thread th2 = new Thread(testV0.Add2);

            th1.Start();
            th2.Start();
            th1.Join();
            th2.Join();

            Console.WriteLine($"V0：count = {testV0.count}");
        }

答案：100萬 到 200萬之間的隨機數。

為什麼？

接下來我們去深入瞭解一下為什麼會這樣？

一、可見性

首先我們來到 “可見性” 這個陌生的詞彙身邊。

通過一番交談了解到：

對可見性進行一下總結就是我改的東西你能同時看到。

1.1 背景

解讀一下呢，就像下面這樣：

CPU 記憶體 硬碟 ，處理速度上存在很大的差距，為了彌補這種差距，也是為了利用CPU強大計算能力。

CPU 和記憶體之前加入了快取，就是我們經常聽說的 暫存器快取、L1、2、3級快取。

應該的處理流程是這樣的：讀取記憶體資料，快取到CPU快取中，CPU進行計算後，從CPU快取中寫回記憶體。

1.2 執行緒切換

還有一點 我們都知道多執行緒其實是通過切換時間片來達到 “同時” 處理問題的假象。

執行緒切換

1.3 單核時代

你也發現了，對於單核來說，程式其實還是序列開發的。

單核CPU

就像是 “一個人” ，東干點，西乾點，如果切換頻率上再快點速度，比我們的眨眼時間還短呢？那……

接下來，我們進入了多核時代。

1.4多核時代

顧名思義，多個CPU，也就是每個CPU核心都有自己的快取體系，但是記憶體只有一份。

比如CPU就是我麼們的本地快取，而記憶體相當於資料庫。

我們每個人的本地快取極有可能是不一樣的，如果我們拿著這些快取直接做一些業務計算，

結果可想而知，多核時代，多執行緒併發也會有這樣的問題 — CPU快取的資料不一樣咋辦？

多核CPU

1.5 volatile

這是CLR 為我們提出的解決方案，就是在遇到可見性引發的併發問題時，使用 volatile 關鍵字。

就是告訴 CPU，我不想用你的快取，所有的請求都直接讀寫記憶體。

一句話，就是禁用快取。

看上去這樣就能解決併發問題了吧？也不全是，還有下面這種槍情況。

二、有序性

字面意義就是有順序，那麼是什麼有順序呢？-- 程式碼

程式碼其實並不是我們所寫的那樣一五一十地執行，以C# 為例：

程式碼 --> IL --> Jit --> cpu 指令

程式碼 通過編譯器的優化生成了IL

CPU也會根據自己的優化重新排列指令順序

至少兩個點會有存在調整 程式碼順序/指令順序的可能。

2.1 猜猜 Debug和Release 執行結果各是多少

public class VolatileTest
    {
        public int falg = 0;
    }
static void VolatileTest()
        {
            VolatileTest volatiler = new VolatileTest();

            new Thread(
               p =>
               {
                   Thread.Sleep(1000);
                   volatiler.falg = 255;
               }).Start();

            while (true)
            {
                if (volatiler.falg == 255)
                {
                    break;
                }
            };

            Console.WriteLine("OK");
        }

主執行緒一直自旋，直到子執行緒將值改變就退出，顯示 “OK”

Debug 版本，執行結果：

Debug

Release 版本，執行結果：

Release

為什麼會這樣，因為我們的程式碼會經過編譯器優化，CPU指令優化，

語句的順序會發生改變，但是這樣也是這種離奇bug產生的一種方式。

怎麼避免它？

2.2 volatile

沒錯，依然是它，不僅僅是禁用cpu快取，而且還能禁止指令和編譯優化。

至少上面的那個例子我們可以再試試：

public class VolatileTest
    {
        public volatile int falg = 0;
    }

volatile 釋出版

到這裡應該就可以了吧，volatile 真好用，一個關鍵字就搞定。

正如你所想，依然沒有結束。

三、原子性

我們平時經常遇到要給一段程式碼區域加上鎖，比如這樣：

lock (lockObj)
                {
                    count++;
                }

我麼們為什麼要加鎖呢？你說為了執行緒同步，為什麼加鎖就能保證執行緒同步而不是其他方式？

3.1count++

說到這裡，我們需要再瞭解一個問題：count++

我們經常寫這樣的程式碼，那麼count++ 最終轉換成cpu指令會是什麼樣子呢？

指令1： 從記憶體中讀取 count

指令2：將 count +1

指令3：將新計算的count值，寫回記憶體

我們將這個count++ 操作和執行緒切換進行結合

count++ 執行緒切換

這裡才是真正解答了最開始為什麼是 100萬到200之間的隨機數。

解決 原子性問題的方法有很多，比如鎖

3.2 lock

加鎖這個程式碼我就暫且忽略，因為lock我們並不陌生。

但是需要明白一點，lock() 是微軟提供給我們的語法糖，其實最終使用的是 Monitor,並且做了異常和資源處理。

lock

CLR 鎖原理

C# 併發程式設計

多個執行緒訪問同一個例項下的共享變數，同時將同步塊索引從 -1 改成CLR維護的同步塊陣列，

用完就會將例項的同步快變成-1

3.3 Monitor

上面提到了隱姓埋名的Monitor，其實我們也可以拋頭露面地使用Monitor

這裡也不具體細說。具體使用可以參照上面圖片。

3.4 System.Threading.Interlocked

官方定義：原子性的簡單操作，累加值，改變值等

區區 count++ 使用lock 有點浪費，我們使用更加輕量級的 Interlocked，

為我們的 count ++ 保駕護航。

 public class ThreadTest_V3
    {
        public volatile int count = 0;
        public void Add1()
        {
            int index = 0;
            while (index++ < 1000000)//100萬次
            {
                Interlocked.Add(ref count, 1);
            }
        }

        public void Add2()
        {
            int index = 0;
            while (index++ < 1000000)//100萬次
            {
                Interlocked.Add(ref count, 1);
            }
        }
    }

結果不多說，依然穩穩的 200萬。

3.5 System.Threading.SpinLock結構

自旋鎖結構，可以這樣理解。

多執行緒訪問共享資源時，只有一個執行緒可以拿到鎖，其他執行緒都在原地等待，

直到這個鎖被釋放，原地等待的資源又一次進行搶佔，以此類推。

在具體使用 System.Threading.SpinLock結構 之前，我們根據剛剛講過的 System.Threading.Interlocked，進行一下改造：

public struct Spin
    {
        private int m_lock;//0=unlock ,1=lock
        public void Enter()
        {
            while (System.Threading.Interlocked.Exchange(ref m_lock, 1) != 0)
            {
                //可以限制自旋次數和時間，自動斷開退出
            }
        }

        public void Exit()
        {
            System.Threading.Interlocked.Exchange(ref m_lock, 0);
        }
    }
public class ThreadTest_V4
    {
        private Spin spin = new Spin();
        public volatile int count = 0;
        public void Add1()
        {
            int index = 0;
            while (index++ < 1000000)//100萬次
            {
                spin.Enter();
                count++;
                spin.Exit();
            }
        }

        public void Add2()
        {
            int index = 0;
            while (index++ < 1000000)//100萬次
            {
                spin.Enter();
                count++;
                spin.Exit();
            }
        }
    }

Enter() , m_lock 從0到1，就是加鎖；

鎖的是共享資源 count;

其他執行緒原地自旋等待（迴圈）

Exit()，m_lock 從1到0，就是解鎖；

System.Threading.SpinLock 結構和以上實現思想類似。

後面的內容就簡單提一下定義和應用場景，有必要的就可以單獨細查。

3.6 System.Threading.SpinWait結構

提供了基於自旋等待支援。
線上程必須等待發出事件訊號或滿足條件時方可使用.

3.7 System.Threading.ReaderWriterLockSlim類

授予獨佔訪問共享資源的寫作，
並允許多個執行緒同時訪問資源進行讀取。

3.8 CAS

cas 核心思想：
將 count 從記憶體讀取出來並賦值給一個區域性變數，叫做 originalData;

然後這個區域性變數 +1 並賦值給新值，叫做 newData;

再次從記憶體中將count讀取出來，如果originalData ==count，

說明沒有執行緒修改記憶體中count值，可以將新值儲存到記憶體中。

反之則可以選擇自旋或者其他策略。

當然還有程式之間的同步，這裡就不一一展開說了。
總結一下：
併發三要素 可見性、有序性、原子性

幾種鎖原理和CAS操作

相關文章