C# lock 自旋鎖，互斥鎖，混合鎖，讀寫鎖介紹

 c# 並行編程、多線程開發中，經常要用到線程鎖，so, 看了許多文章，想總結一下，供自己理解記憶，以及園丁們參考使用，理解的不怎么全面，勿噴！在多線程環境中，多個線程可能會同時訪問同一個資源，為了避免訪問發生沖突，可以根據訪問的復雜程度采取不同的措施，原子操作適用於簡單的單個操作，無鎖算法適用於相對簡單的一連串操作，而線程鎖適用於復雜的一連串操作

1.lock鎖的解釋和用法

官方MSDN的說法：lock 關鍵字可確保當一個線程位於代碼的臨界區時，另一個線程不會進入該臨界區。 如果其他線程嘗試進入鎖定的代碼，則它將一直等待（即被阻止），直到該對象被釋放。lock 關鍵字在塊的開始處調用 Enter，而在塊的結尾處調用 Exit。 ThreadInterruptedException 引發，如果 Interrupt 中斷等待輸入 lock 語句的線程。通常，應避免鎖定 public 類型，否則實例將超出代碼的控制范圍。

private static readonly object objlock = new object();
lock (objlock )
{
    //要執行的代碼邏輯
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace LockTest
{
    class Program
    {
        static void Main(string[] args)
        {
            TestLock testlock = new TestLock();
            Thread th = new Thread(() =>
            {
                //模擬死鎖：造成死鎖，使lock無法釋放，在i=5時，跳出死循環，釋放lock
                testlock.DoWorkWithLock();
            });
            th.Start();
            Thread.Sleep(1000);
            Thread th2 = new Thread(() =>
            {              
                //這個地方你可能會有疑惑，但存在這種情況，比如你封裝的dll，對其它開發人員不是可見的
                //開發人員很有可能在他的邏輯中，加上一個lock保證方法同時被一個線程調用，但這時有其它的線程正在調用該方法，
                //但並沒有釋放，死鎖了，那么在這里就不會被執行，除非上面的線程釋放了lock鎖定的對象。這里的lock也可以理解為一個標識，線程1被鎖定的對象
                //是否已經被釋放，
                //如果沒有釋放，則無法繼續訪問lock塊中的代碼。
                lock (testlock)
                {
                    // 如果該對象中lock(this)不釋放（testlock與this指的是同一個對象），則其它線程如果調用該方法，則會出現直到lock(this)釋放后才能繼續調用。  
                    testlock.MotherCallYouDinner();
                    testlock.DoWorkWithLock();
                }
            });
            th2.Start();
            Console.Read();
        }
    }

    class TestLock
    {
        public static readonly object objLock = new object();
        /// <summary>
        ///  該方法，希望某人在工作的時候，其它人不要打擾（希望只有一個線程在執行)
        /// </summary>
        /// <param name="methodIndex"></param>
        public void DoWorkWithLock()
        {
            //鎖當前對象
            lock (this)
            {
                Console.WriteLine("lock this");
                int i = 0;
                while (true)
                {
                    Console.WriteLine("At work, do not disturb...,Thread id is " + Thread.CurrentThread.ManagedThreadId.ToString());
                    Thread.Sleep(1000);
                    if (i == 5)
                    {
                        break;
                    }
                    Console.WriteLine(i.ToString());
                    i++;
                }
            }
            Console.WriteLine("lock dispose");
        }
        public void MotherCallYouDinner()
        {
            Console.WriteLine("Your mother call you to home for dinner.");
        }
    }
}

demo說明：main方法中，創建了一個對象testlock對象，線程1執行該對象的DoWorkWithLock方法，因為死鎖（5s后釋放），造成lock(this)無法釋放，則導致了方法MotherCallYouDinner，DoWorkWithLock在線程2中無法被調用，直到lock(this)釋放，lock(testlock)才能繼續執行，可以這么理解，由於鎖定的同一個對象，線程1釋放了鎖定的對象，其它線程才能訪問。

---

 那么通過lock(static object)方式呢，能不能保證lock塊內的方法，同時只被一個線程執行呢，並且線程2能訪問到MotherCallYouDinner方法。而不像上面出現的那種情況，如果不釋放lock(this)，導致線程2都無法執行代碼邏輯。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace LockTest
{
    class Program
    {
        static void Main(string[] args)
        {
            TestLock testlock = new TestLock();
            Thread th = new Thread(() =>
            {
                //模擬死鎖：造成死鎖，使lock無法釋放，在i=5時，跳出死循環，釋放lock
                testlock.DoWorkWithLock();
            });
            th.Start();
            Thread.Sleep(1000);
            Thread th2 = new Thread(() =>
            {              
               
                lock (testlock)
                {                
                    testlock.MotherCallYouDinner();
                    testlock.DoWorkWithLock();
                }
            });
            th2.Start();
            Console.Read();
        }
    }

    class TestLock
    {
        private static readonly object objLock = new object();
        /// <summary>
        ///  該方法，希望某人在工作的時候，其它人不要打擾（希望只有一個線程在執行)
        /// </summary>
        /// <param name="methodIndex"></param>
        public void DoWorkWithLock()
        {
            //鎖
            lock (objLock)
            {
                Console.WriteLine("lock this");
                int i = 0;
                while (true)
                {
                    Console.WriteLine("At work, do not disturb...,Thread id is " + Thread.CurrentThread.ManagedThreadId.ToString());
                    Thread.Sleep(1000);
                    if (i == 5)
                    {
                        break;
                    }
                    Console.WriteLine(i.ToString());
                    i++;
                }
            }
            Console.WriteLine("lock dispose");
        }
        public void MotherCallYouDinner()
        {
            Console.WriteLine("Your mother call you to home for dinner.");
        }
    }
}

輸出：

可以看到，將lock(this)更換為鎖定私有的靜態對象，線程2執行了，首先輸出了“Your mother call you to home for dinner.”，同時實現了DoWorkWithLock方法中lock的代碼塊當前只被一個線程執行，直到lcok（objlock）被釋放。因為鎖定的對象，外部不能訪問，線程2不再關心lock（this）是不是已經釋放，都會執行，當然也保證了方法DoWorkWithLock同時被一個線程訪問。

總結：

1、避免使用lock(this)，因為無法保證你提供的方法，在外部類中使用的時候，開發人員會不會鎖定當前對象。

通常，應避免鎖定 public 類型，否則實例將超出代碼的控制范圍。常見的結構 lock (this)、lock (typeof (MyType)) 和 lock ("myLock") 違反此准則：

• 如果實例可以被公共訪問，將出現 lock (this) 問題。

• 如果 MyType 可以被公共訪問，將出現 lock (typeof (MyType)) 問題。

• 由於進程中使用同一字符串的任何其他代碼將共享同一個鎖，所以出現 lock(“myLock”) 問題。

最佳做法是定義 private 對象來鎖定, 或 private static 對象變量來保護所有實例所共有的數據。

這里只是說明lock(this)的問題，雖然極端。但開發中，不能保證不會發生。

2、最好使用私有的靜態只讀的鎖對象，保證不會影響其他邏輯的正常執行。

3、盡量避免死鎖的發生。

2.lock自旋鎖、互斥鎖、混合鎖、讀寫鎖

1. 自旋鎖：自旋鎖（Spinlock）是最簡單的線程鎖，基於原子操作實現，它使用一個數值來表示鎖是否已經被獲取，0表示未被獲取，1表示已經獲取，獲取鎖時會先使用原子操作設置數值為1，然后檢查修改前的值是否為0，如果為0則代表獲取成功，否則繼續重試直到成功為止，釋放鎖時會設置數值為0，其他正在獲取鎖的線程會在下一次重試時成功獲取，使用原子操作的原因是，它可以保證多個線程同時把數值0修改到1時，只有一個線程可以觀察到修改前的值為0，其他線程觀察到修改前的值為1

.NET 可以使用以下的類實現自旋鎖：

System.Threading.Thread.SpinWait

System.Threading.SpinWait

System.Threading.SpinLock

使用自旋鎖有個需要注意的問題，自旋鎖保護的代碼應該在非常短的時間內執行完畢，如果代碼長時間運行則其他需要獲取鎖的線程會不斷重試並占用邏輯核心，影響其他線程運行，此外，如果 CPU 只有一個邏輯核心，自旋鎖在獲取失敗時應該立刻調用 Thread.Yield 函數提示操作系統切換到其他線程，因為一個邏輯核心同一時間只能運行一個線程，在切換線程之前其他線程沒有機會運行，也就是切換線程之前自旋鎖沒有機會被釋放

自旋鎖的使用：

　　 class Program
    {
        static void Main(string[] args)
        {
            var count = 0;
            var taskList = new Task[10];
            Stopwatch sp = new Stopwatch();
            sp.Start();

            // 不要意外復制。每個實例都是獨立的。
            SpinLock _spinLock = new SpinLock();
            for (int i = 0; i < taskList.Length; i++)
            {
                taskList[i] = Task.Run(() =>
                {
                    bool _lock = false;
                    for (int j = 0; j < 10_000_000; j++)
                    {
                        _spinLock.Enter(ref _lock);
                        count++;
                        _spinLock.Exit();
                        _lock = false;
                    }
                });
            }

            sp.Stop();
            Task.WaitAll(taskList);
            Console.WriteLine($"完成! 耗時:{sp.ElapsedTicks}");
            Console.WriteLine($"結果:{count}");
        }
    }

自旋鎖的簡單用法

using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Sample5_4_spinlock
{
    class Program
    {
        private static int _TaskNum = 3;
        private static Task[] _Tasks;
        private static StringBuilder _StrBlder;
        private const int RUN_LOOP = 50;

        private static SpinLock m_spinlock;

        private static void Work1(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;
            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  =====\n",
                                    DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    m_spinlock.Enter(ref lockToken);
                    _StrBlder.Append(log);
                }
                finally
                {
                    if (lockToken)
                        m_spinlock.Exit(false);
                }
            }
        }

        private static void Work2(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;

            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  *****\n",
                                    DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    m_spinlock.Enter(ref lockToken);
                    _StrBlder.Append(log);
                }
                finally
                {
                    if (lockToken)
                        m_spinlock.Exit(false);
                }
            }
        }

        private static void Work3(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;

            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  ~~~~~\n",
                                    DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    m_spinlock.Enter(ref lockToken);
                    _StrBlder.Append(log);
                }
                finally
                {
                    if (lockToken)
                        m_spinlock.Exit(false);
                }
            }
        }

        static void Main(string[] args)
        {
            _Tasks = new Task[_TaskNum];
            _StrBlder = new StringBuilder();
            m_spinlock = new SpinLock();


            _Tasks[0] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work1(taskid);
            }, 0);

            _Tasks[1] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work2(taskid);
            }, 1);

            _Tasks[2] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work3(taskid);
            }, 2);

            var finalTask = Task.Factory.ContinueWhenAll(_Tasks, (tasks) =>
            {
                Task.WaitAll(_Tasks);
                Console.WriteLine("==========================================================");
                Console.WriteLine("All Phase is completed");
                Console.WriteLine("==========================================================");
                Console.WriteLine(_StrBlder);
            });

            try
            {
                finalTask.Wait();
            }
            catch (AggregateException aex)
            {
                Console.WriteLine("Task failed And Canceled" + aex.ToString());
            }
            finally
            {
            }
            Console.ReadLine();
        }
    }
}

在每個任務的finally塊中，會調用SpinLock的release，否則在SpinLock.Enter中，程序會在循環中不斷的嘗試獲得鎖，造成死鎖。一旦獲得了鎖，ref 的 LockToken會被變成 true。

超時的用法：SpinLock 同樣也提供了超時機制供開發使用。一個程序示例，worker 1會造成超時，work 2 和work 3則在程序中捕獲超時產生的異常，終止運行。

using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Sample5_5_spinlock_timeout
{
    class Program
    {
        private static int _TaskNum = 3;
        private static Task[] _Tasks;
        private static StringBuilder _StrBlder;
        private const int RUN_LOOP = 50;
        private static SpinLock m_spinlock;


        private static void Work1(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;
            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  =====\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    m_spinlock.TryEnter(2000, ref lockToken);
                    if (!lockToken)
                    {
                        Console.WriteLine("Work1 TIMEOUT!! Will throw Exception");
                        throw new TimeoutException("Work1 TIMEOUT!!");
                    }
                    System.Threading.Thread.Sleep(5000);
                    _StrBlder.Append(log);
                }
                finally
                {
                    if (lockToken)
                        m_spinlock.Exit(false);
                }
            }
        }

        private static void Work2(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;

            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  *****\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    m_spinlock.TryEnter(2000, ref lockToken);
                    if (!lockToken)
                    {
                        Console.WriteLine("Work2 TIMEOUT!! Will throw Exception");
                        throw new TimeoutException("Work2 TIMEOUT!!");
                    }

                    _StrBlder.Append(log);
                }
                finally
                {
                    if (lockToken)
                        m_spinlock.Exit(false);
                }
            }
        }

        private static void Work3(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;

            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  ~~~~~\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    m_spinlock.TryEnter(2000, ref lockToken);
                    if (!lockToken)
                    {
                        Console.WriteLine("Work3 TIMEOUT!! Will throw Exception");
                        throw new TimeoutException("Work3 TIMEOUT!!");
                    }
                    _StrBlder.Append(log);
                }
                finally
                {
                    if (lockToken)
                        m_spinlock.Exit(false);
                }
            }
        }

        static void Main(string[] args)
        {
            _Tasks = new Task[_TaskNum];
            _StrBlder = new StringBuilder();
            m_spinlock = new SpinLock();

            _Tasks[0] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work1(taskid);
            }, 0);

            _Tasks[1] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work2(taskid);
            }, 1);

            _Tasks[2] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work3(taskid);
            }, 2);

            var finalTask = Task.Factory.ContinueWhenAll(_Tasks, (tasks) =>
            {
                Task.WaitAll(_Tasks);
                Console.WriteLine("==========================================================");
                Console.WriteLine("All Phase is completed");
                Console.WriteLine("==========================================================");
                Console.WriteLine(_StrBlder);
            });

            try
            {
                finalTask.Wait();
            }
            catch (AggregateException aex)
            {
                Console.WriteLine("Task failed And Canceled" + aex.ToString());
            }
            finally
            {
            }
            Console.ReadLine();
        }

    }
}

操作 SpinWait 的另一種方式 – 實例化 SpinWait。

SpinWait 提供了兩個方法和兩個只讀屬性。

方法：

SpinWait.Reset() : 重置自旋計數器，將計數器置 0。效果就好像沒調用過SpinOnce一樣。
SpinWait.Once() : 執行一次自旋。當SpinWait自旋達到一定次數后，如果有必要當前線程會讓出底層的時間片並觸發上下文切換。
屬性：

SpinWait.Count：方法執行單次自旋的次數。
SpinWait.NextSpinWillYield：一個bool值，表示下一次通過SpinOnce方法自旋是否會讓出底層線程的時間片並發生上下文切換。

如果需要等待某個條件滿足的時間很短，而且不希望發生上下文切換，基於自旋的【等待】是一種很好的解決方案。

SpinWait ： 自旋等待
SpinUntil ： 等待某個條件發生
如果發生了長時間的自旋，SpinWait會讓出底層的時間片，並觸發上下文切換。因為長時間的自旋會阻塞優先級更高的線程。當一個線程自旋時，它會將一個內核放入到一個繁忙的循環中，而且它不會讓出處理器時間片的剩余部分。SpinWait的智能邏輯中會在自旋達到足夠長的時間時停止自旋並讓出處理器。當然可以考慮調用Thread.Sleep()方法，它會讓出處理器時間，但開銷比較大。

示例程序：這里通過使用SpinWait 來控制3個Task的執行順序。

using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Sample5_6_spinwait
{
    class Program
    {
        private static int _TaskNum = 3;
        private static Task[] _Tasks;
        private static StringBuilder _StrBlder;
        private const int RUN_LOOP = 10;
        private static bool m_IsWork2Start = false;
        private static bool m_IsWork3Start = false;

        private static void Work1(int TaskID)
        {
            int i = 0;
            string log = "";

            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  =====\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    _StrBlder.Append(log);
                }
                finally
                {
                    m_IsWork2Start = true;
                }
            }
        }

        private static void Work2(int TaskID)
        {
            int i = 0;
            string log = "";

            System.Threading.SpinWait.SpinUntil(() => m_IsWork2Start);

            while ((i < RUN_LOOP) && (m_IsWork2Start))
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  *****\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    _StrBlder.Append(log);
                }
                finally
                {
                    m_IsWork3Start = true;
                }
            }
        }

        private static void Work3(int TaskID)
        {
            int i = 0;
            string log = "";

            System.Threading.SpinWait.SpinUntil(() => m_IsWork3Start);

            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  ~~~~~\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    _StrBlder.Append(log);
                }
                finally
                {
                }
            }
        }

        static void Main(string[] args)
        {
            _Tasks = new Task[_TaskNum];
            _StrBlder = new StringBuilder();

            _Tasks[0] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work1(taskid);
            }, 0);

            _Tasks[1] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work2(taskid);
            }, 1);

            _Tasks[2] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work3(taskid);
            }, 2);

            var finalTask = Task.Factory.ContinueWhenAll(_Tasks, (tasks) =>
            {
                Task.WaitAll(_Tasks);
                Console.WriteLine("==========================================================");
                Console.WriteLine("All Phase is completed");
                Console.WriteLine("==========================================================");
                Console.WriteLine(_StrBlder);
            });

            try
            {
                finalTask.Wait();
            }
            catch (AggregateException aex)
            {
                Console.WriteLine("Task failed And Canceled" + aex.ToString());
            }
            finally
            {
            }
            Console.ReadLine();
        }
    }
}

總結：

自旋鎖可用於葉級鎖, 在這種情況Monitor下, 通過使用、大小或由於垃圾回收壓力而隱含的對象分配的成本非常高。 旋轉鎖定有助於避免阻塞;但是, 如果你預計會有大量的阻塞, 則可能由於旋轉過多而無法使用自旋鎖。 當鎖的粒度較大且數值較大 (例如, 鏈接列表中的每個節點都有一個鎖) 以及鎖保留時間始終極短時, 旋轉可能非常有利。 通常, 在持有自旋鎖時, 應避免使用以下任何操作:

• 堵塞

• 調用自身可能會阻止的任何內容,

• 同時保留多個自旋鎖,

• 進行動態調度的調用 (interface 和虛方法),

• 對任何代碼進行靜態調度調用, 而不是任何代碼, 或

• 分配內存。

SpinLock僅應在確定這樣做后使用才能改善應用程序的性能。 出於性能方面的考慮, 還SpinLock必須注意, 是值類型。 出於此原因, 必須注意不要意外復制SpinLock實例, 因為兩個實例 (原始和副本) 將完全獨立, 這可能會導致應用程序出現錯誤的行為。 如果必須傳遞實例, 則它應按引用而不是按值傳遞。 SpinLock

不要在只讀SpinLock字段中存儲實例。

 

2. 互斥鎖：Monitor 和 mutex

定義：private static readonly object Lock = new object();

使用：Monitor.Enter(Lock);   //todo Monitor.Exit(Lock);

作用：將會鎖住代碼塊的內容，並阻止其他線程進入該代碼塊，直到該代碼塊運行完成，釋放該鎖。

注意：定義的鎖對象應該是 私有的，靜態的，只讀的，引用類型的對象，這樣可以防止外部改變鎖對象

Monitor有TryEnter的功能，可以防止出現死鎖的問題，lock沒有

 定義：private static readonly Mutex mutex = new Mutex();

使用：mutex.WaitOne(); //todo mutex.ReleaseMutex();

作用：將會鎖住代碼塊的內容，並阻止其他線程進入該代碼塊，直到該代碼塊運行完成，釋放該鎖。

注意：定義的鎖對象應該是 私有的，靜態的，只讀的，引用類型的對象，這樣可以防止外部改變鎖對象

Mutex本身是可以系統級別的，所以是可以跨越進程的

Monitor 測試實現：

using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Sample5_2_monitor_lock
{
    class Program
    {
        private static int _TaskNum = 3;
        private static Task[] _Tasks;
        private static StringBuilder _StrBlder;
        private const int RUN_LOOP = 50;

        private static void Work1(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;
            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  =====\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    Monitor.Enter(_StrBlder, ref lockToken);
                    _StrBlder.Append(log);
                }
                finally 
                {
                    if (lockToken)
                        Monitor.Exit(_StrBlder);
                }
            }
        }

        private static void Work2(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;

            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  *****\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    Monitor.Enter(_StrBlder, ref lockToken);
                    _StrBlder.Append(log);
                }
                finally
                {
                    if (lockToken)
                        Monitor.Exit(_StrBlder);
                }
            }
        }

        private static void Work3(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;

            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  ~~~~~\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    Monitor.Enter(_StrBlder, ref lockToken);
                    _StrBlder.Append(log);
                }
                finally
                {
                    if (lockToken)
                        Monitor.Exit(_StrBlder);
                }
            }
        }

        static void Main(string[] args)
        {
            _Tasks = new Task[_TaskNum];
            _StrBlder = new StringBuilder();

            _Tasks[0] = Task.Factory.StartNew((num) =>
                {
                    var taskid = (int)num;
                    Work1(taskid);
                }, 0);

            _Tasks[1] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work2(taskid);
            }, 1);

            _Tasks[2] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work3(taskid);
            }, 2);

            var finalTask = Task.Factory.ContinueWhenAll(_Tasks, (tasks) =>
            {
                Task.WaitAll(_Tasks);
                Console.WriteLine("==========================================================");
                Console.WriteLine("All Phase is completed");
                Console.WriteLine("==========================================================");
                Console.WriteLine(_StrBlder);
            });

            try
            {
                finalTask.Wait();
            }
            catch (AggregateException aex)
            {
                Console.WriteLine("Task failed And Canceled" + aex.ToString());
            }
            finally
            {
            }
            Console.ReadLine();
        }
    }
}

鎖超時的使用：

其中主要使用的是 Monitor.TryEnter(),函數，其中多了一個設置超時時間的參數。 
代碼中讓每個鎖的超時Timer為2秒，在Work1中挺頓5秒，這樣造成了Work2和Work3的超時。

using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Sample5_3_monitor_lock_timeout
{
    class Program
    {
        private static int _TaskNum = 3;
        private static Task[] _Tasks;
        private static StringBuilder _StrBlder;
        private const int RUN_LOOP = 50;

        private static void Work1(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;
            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  =====\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    Monitor.TryEnter(_StrBlder, 2000, ref lockToken);
                    if (!lockToken)
                    {
                        Console.WriteLine("Work1 TIMEOUT!! Will throw Exception");
                        throw new TimeoutException("Work1 TIMEOUT!!");
                    }
                    System.Threading.Thread.Sleep(5000);
                    _StrBlder.Append(log);
                }
                finally
                {
                    if (lockToken)
                        Monitor.Exit(_StrBlder);
                }
            }
        }

        private static void Work2(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;

            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  *****\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    Monitor.TryEnter(_StrBlder, 2000, ref lockToken);
                    if (!lockToken)
                    {
                        Console.WriteLine("Work2 TIMEOUT!! Will throw Exception");
                        throw new TimeoutException("Work2 TIMEOUT!!");
                    }

                    _StrBlder.Append(log);
                }
                finally
                {
                    if (lockToken)
                        Monitor.Exit(_StrBlder);
                }
            }
        }

        private static void Work3(int TaskID)
        {
            int i = 0;
            string log = "";
            bool lockToken = false;

            while (i < RUN_LOOP)
            {
                log = String.Format("Time: {0}  Task : #{1}  Value: {2}  ~~~~~\n",
                                  DateTime.Now.TimeOfDay, TaskID, i);
                i++;
                try
                {
                    lockToken = false;
                    Monitor.TryEnter(_StrBlder, 2000, ref lockToken);
                    if (!lockToken)
                    {
                        Console.WriteLine("Work3 TIMEOUT!! Will throw Exception");
                        throw new TimeoutException("Work3 TIMEOUT!!");
                    }
                    _StrBlder.Append(log);
                }
                finally
                {
                    if (lockToken)
                        Monitor.Exit(_StrBlder);
                }
            }
        }

        static void Main(string[] args)
        {
            _Tasks = new Task[_TaskNum];
            _StrBlder = new StringBuilder();

            _Tasks[0] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work1(taskid);
            }, 0);

            _Tasks[1] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work2(taskid);
            }, 1);

            _Tasks[2] = Task.Factory.StartNew((num) =>
            {
                var taskid = (int)num;
                Work3(taskid);
            }, 2);

            var finalTask = Task.Factory.ContinueWhenAll(_Tasks, (tasks) =>
            {
                Task.WaitAll(_Tasks);
                Console.WriteLine("==========================================================");
                Console.WriteLine("All Phase is completed");
                Console.WriteLine("==========================================================");
                Console.WriteLine(_StrBlder);
            });

            try
            {
                finalTask.Wait();
            }
            catch (AggregateException aex)
            {
                Console.WriteLine("Task failed And Canceled" + aex.ToString());
            }
            finally
            {
            }
            Console.ReadLine();
        }
    }
}

 mutex 測試實現 ：

1、initiallyOwned表示創建mutex的線程是否擁有該互斥體。true表示創建線程擁有互斥鎖，只有在創建線程中調用ReleaseMutex釋放后，其他等待線程才能參與搶奪互斥體的活動。false表示互斥鎖體於與空閑狀態，其他等待互斥鎖的線程立即參與到搶奪互斥鎖的活動中去。

2、在上面程序中如果創建mutex時使用true參數，故在啟動其他線程后必須執行mutex.ReleaseMutex()，如果不釋放mutex，則其他線程將一直等待下去。使用ture，相當於一創建就使用waitone()

3、mutex.WaitOne()與mutex.ReleaseMutex()要像 { } 一樣配對使用，否則將出現 "由於出現被放棄的 mutex，等待過程結束" 的異常

4、mutex與monitor相比，沒有暫時釋放的功能；因此mutex一經釋放，原釋放資源的線程也將重新參與新一輪對mutex的爭奪過程。

    　　　　　using (var mutex = new Mutex(false, "name"))
            {
                try
                {
                    mutex.WaitOne();
                    //do something
                }
                catch(Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    mutex.ReleaseMutex();
                }
            }  

不舉栗子了：https://www.cnblogs.com/leo_wl/archive/2012/03/23/2413200.html，，，，https://www.cnblogs.com/guozhiming2003/archive/2008/09/16/1291953.html

3. 混合鎖

混合鎖的特征是在獲取鎖失敗后像自旋鎖一樣重試一定的次數，超過一定次數之后（.NET Core 2.1 是30次）再安排當前進程進入等待狀態

混合鎖的好處是，如果第一次獲取鎖失敗，但其他線程馬上釋放了鎖，當前線程在下一輪重試可以獲取成功，不需要執行毫秒級的線程調度處理；而如果其他線程在短時間內沒有釋放鎖，線程會在超過重試次數之后進入等待狀態，以避免消耗 CPU 資源，因此混合鎖適用於大部分場景

internal sealed class SimpleHybridLock : IDisposable
    {
        //基元用戶模式構造使用
        private int m_waiters = 0;

        //基元內核模式構造
        private AutoResetEvent m_waiterLock = new AutoResetEvent(false);

        public void Enter()
        {
            //指出該線程想要獲得鎖
            if (Equals(Interlocked.Increment(ref m_waiters), 1))
            {
                //無競爭，直接返回
                return;
            }

            //另一個線程擁有鎖（發生競爭），使這個線程等待
            //線程會阻塞，但不會在CPU上“自旋”，從而節省CPU
            //這里產生較大的性能影響（用戶模式與內核模式之間轉換）
            //待WaitOne返回后，這個線程拿到鎖
            m_waiterLock.WaitOne();
        }

        public void Leave()
        {
            //該線程准備釋放鎖
            if (Equals(Interlocked.Decrement(ref m_waiters), 0))
            {
                //無線程等待，直接返回
                return;
            }

            //有線程等待則喚醒其中一個
            //這里產生較大的性能影響（用戶模式與內核模式之間轉換）
            m_waiterLock.Set();
        }

        public void Dispose()
        {
            m_waiterLock.Dispose();
        }
    }

4.讀寫鎖(ReaderWriterLock )

ReaderWriterLock 定義支持單個寫線程和多個讀線程的鎖。該鎖的作用主要是解決並發讀的性能問題，使用該鎖，可以大大提高數據並發訪問的性能，只有在寫時，才會阻塞所有的讀鎖。

using System.Collections.Generic;
using System.Windows;
using System.Threading;
 
 
namespace FYSTest
{
    public partial class MainWindow : Window
    {
        List<int> list = new List<int>();
        private ReaderWriterLock _rwlock = new ReaderWriterLock();
 
        public MainWindow()
        {
            InitializeComponent();
            Thread ThRead = new Thread(new ThreadStart(Read));
            ThRead.IsBackground = true;
            Thread ThRead2 = new Thread(new ThreadStart(Read));
            ThRead2.IsBackground = true;
            Thread ThWrite = new Thread(new ThreadStart(Write));
            ThWrite.IsBackground = true;
            ThRead.Start();
            ThRead2.Start();
            ThWrite.Start();
        }
 
        private void Read()
        {
            while (true)
            {
                //使用一個 System.Int32 超時值獲取讀線程鎖。
                _rwlock.AcquireReaderLock(100);
                try
                {
                    if (list.Count > 0)
                    {
                        int result = list[list.Count - 1];
                    }
                }
                finally
                {
                    //減少鎖計數,釋放鎖
                    _rwlock.ReleaseReaderLock();
                }
            }
        }
 
        int WriteCount = 0;//寫次數
        private void Write()
        {
            while (true)
            {
                //使用一個 System.Int32 超時值獲取寫線程鎖。
                _rwlock.AcquireWriterLock(100);
                try
                {
                    list.Add(WriteCount++);
                }
                finally
                {
                    //減少寫線程鎖上的鎖計數，釋放寫鎖
                    _rwlock.ReleaseWriterLock();
                }
            }
        }
    }
}

讀寫鎖的具體用法栗子：https://blog.csdn.net/zdhlwt2008/article/details/80702605

好了終於寫完了，一大堆，寫也累，看也累，何苦，看不下去不要看了，總結一下供查閱吧！！！！！！