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}  =====
",
                                    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}  *****
",
                                    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}  ~~~~~
",
                                    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}  =====
",
                                  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}  *****
",
                                  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}  ~~~~~
",
                                  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}  =====
",
                                  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}  *****
",
                                  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}  ~~~~~
",
                                  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}  =====
",
                                  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}  *****
",
                                  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}  ~~~~~
",
                                  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}  =====
",
                                  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}  *****
",
                                  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}  ~~~~~
",
                                  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

好了终于写完了，一大堆，写也累，看也累，何苦，看不下去不要看了，总结一下供查阅吧！！！！！！