第十二节：深究内核模式锁的使用场景(自动事件锁、手动事件锁、信号量、互斥锁、读写锁、动态锁)

一. 整体介绍

温馨提示：内核模式锁，在不到万不得已的情况下，不要使用它，因为代价太大了，有很多种替代方案。

　　内核模式锁包括：

　　　　①：事件锁

　　　　②：信号量

　　　　③：互斥锁

　　　　④：读写锁

　　　　⑤：动态锁

二. 事件锁

 事件锁包括：

A. 自动事件锁(AutoResetEvent)

　　使用场景：可以用此锁实现多线程环境下某个变量的自增.

　　现实场景： 进站火车闸机，我们用火车票来实现进站操作.

　　true: 表示终止状态,闸机中没有火车票

　　false: 表示费终止状态，闸机中此时有一张火车票

B.手动事件锁(ManualResetEvent)

　　现实场景：有人看守的铁道栅栏(和自动事件锁不一样，不能混用)

　　true： 栅栏没有合围，没有阻止行人通过铁路

　　false：栅栏合围了， 阻止行人通过

* 下面案例发现，锁不住，自增仍然是无序的输出了.

* 核心方法：WaitOne和Set

 代码实践-自动事件锁：

 static AutoResetEvent autoResetLock1 = new AutoResetEvent(true);
 static AutoResetEvent autoResetLock2 = new AutoResetEvent(false);
 static int num2 = 0;
 {
                //1. 能输出
                {
                    autoResetLock1.WaitOne();
                    Console.WriteLine("autoResetLock1检验通过，可以通行");
                    autoResetLock1.Set();
                }

                //2. 不能输出
                {
                    autoResetLock2.WaitOne();
                    Console.WriteLine("autoResetLock2检验通过，可以通行");
                    autoResetLock2.Set();
                } 

                //3.下面代码的结果：num从0-249，有序的发现可以锁住。
                {
                    for (int i = 0; i < 5; i++)
                    {
                        Task.Factory.StartNew(() =>
                        {
                            for (int j = 0; j < 50; j++)
                            {
                                try
                                {
                                    autoResetLock1.WaitOne();
                                    Console.WriteLine(num2++);
                                    autoResetLock1.Set();
                                }
                                catch (Exception ex)
                                {
                                    Console.WriteLine(ex.Message);
                                }

                            }
                        });
                    }
                }
            }

代码实践-手动事件锁：

 　　　　　　　　static int num2 = 0;
 　　　　　　　　static ManualResetEvent mreLock = new ManualResetEvent(true);
 　　　　　　　　//下面代码锁不住，仍然是无序的输出了
                {
                    for (int i = 0; i < 5; i++)
                    {
                        Task.Factory.StartNew(() =>
                        {
                            for (int j = 0; j < 50; j++)
                            {
                                try
                                {
                                    mreLock.WaitOne();
                                    Console.WriteLine(num2++);
                                    mreLock.Set();
                                }
                                catch (Exception ex)
                                {
                                    Console.WriteLine(ex.Message);
                                }

                            }
                        });
                    }
                }

三. 信号量

信号量：

　　* 核心类：Semaphore，通过int数值来控制线程个数。

　　* 通过观察构造函数 public Semaphore(int initialCount, int maximumCount);：

　　* initialCount: 可以同时授予的信号量的初始请求数。

　　* maximumCount: 可以同时授予的信号量的最大请求数。

　　* static Semaphore seLock = new Semaphore(1, 1); //表示只允许一个线程通过

* 下面的案例可以有序的输出。

* 核心方法：WaitOne和Release

 代码实践：

             static Semaphore seLock = new Semaphore(1, 1); //只允许一个线程通过 
                //下面代码锁住了，可以有序的输出
                {
                    for (int i = 0; i < 5; i++)
                    {
                        Task.Factory.StartNew(() =>
                        {
                            for (int j = 0; j < 50; j++)
                            {
                                try
                                {
                                    seLock.WaitOne();
                                    Console.WriteLine(num2++);
                                    seLock.Release();
                                }
                                catch (Exception ex)
                                {
                                    Console.WriteLine(ex.Message);
                                }

                            }
                        });
                    }
                }

四. 互斥锁

互斥锁：

　　核心方法：WaitOne和ReleaseMutex

　　下面案例可以锁住，有序输出

总结以上三种类型的锁，都有一个WaitOne方法，观察源码可知，都继承于WaitHandle类。

 代码实践：

　　　　　　static Mutex mutex = new Mutex();
 　　　　   //下面代码锁住了，可以有序的输出
                {
                    for (int i = 0; i < 5; i++)
                    {
                        Task.Factory.StartNew(() =>
                        {
                            for (int j = 0; j < 50; j++)
                            {
                                try
                                {
                                    mutex.WaitOne();
                                    Console.WriteLine(num2++);
                                    mutex.ReleaseMutex();
                                }
                                catch (Exception ex)
                                {
                                    Console.WriteLine(ex.Message);
                                }

                            }
                        });
                    }
                }

五. 读写锁

  读写锁(ReaderWriterLock)：

　　背景：多个线程读，一个线程写，如果写入的时间太久，此时读的线程会被卡死，这个时候就要用到读写锁了。

　　锁读的两个核心方法：AcquireReaderLock和ReleaseReaderLock。

　　锁写的两个核心方法：AcquireWriterLock和ReleaseWriterLock。

 代码实践：

       static ReaderWriterLock rwlock = new ReaderWriterLock();
        private void button24_Click(object sender, EventArgs e)
        {
            #region 01-读写锁
            {
                //开启5个线程执行读操作
                for (int i = 0; i < 5; i++)
                {
                    Task.Run(() =>
                    {
                        Read();
                    });
                }
                //开启1个线程执行写操作
                Task.Factory.StartNew(() =>
                {
                    Write();
                });
            }
            #endregion

        }
        /// <summary>
        /// 线程读
        /// </summary>
        static void Read()
        {
            while (true)
            {
                Thread.Sleep(10);
                rwlock.AcquireReaderLock(int.MaxValue);
                Console.WriteLine("当前 t={0} 进行读取 {1}", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
                rwlock.ReleaseReaderLock();
            }
        }
        /// <summary>
        /// 线程写
        /// </summary>
        static void Write()
        {
            while (true)
            {
                Thread.Sleep(300);
                rwlock.AcquireWriterLock(int.MaxValue);
                Console.WriteLine("当前 t={0} 进行写入 {1}", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
                rwlock.ReleaseWriterLock();
            }
        }

六. 动态锁

动态锁(CountdownEvent)：

　　* 作用：限制线程数的一个机制。

　　* 业务场景：有Orders、Products、Users表，我们需要多个线程从某一张表中读取数据。

　　* 比如：Order表10w，10个线程读取。(每个线程读1w)

　　　　　  Product表5w，5个线程读取。(每个线程读1w)

　　　　     User表2w，2个线程读取。(每个线程读1w)

三个核心方法：

　　①.Reset方法：重置当前的线程数量上限。（初始化的时候，默认设置一个上限）

　　②.Signal方法：将当前的线程数量执行减1操作。（使用一个thread，这个线程数量就会减1操作，直到为0后，继续下一步）

　　③.Wait方法：相当于我们的Task.WaitAll方法。

代码实践：

 //初始化线程数量上限为10.
        static CountdownEvent cdLock = new CountdownEvent(10);
        private void button25_Click(object sender, EventArgs e)
        {
            //加载Orders搞定
            cdLock.Reset(10);
            for (int i = 0; i < 10; i++)
            {
                Task.Factory.StartNew(() =>
                {
                    LoadOrder();
                });
            }
            cdLock.Wait();
            Console.WriteLine("所有的Orders都加载完毕。。。。。。。。。。。。。。。。。。。。。");

            //加载Product搞定
            cdLock.Reset(5);
            for (int i = 0; i < 5; i++)
            {
                Task.Run(() =>
                {
                    LoadProduct();
                });
            }
            cdLock.Wait();
            Console.WriteLine("所有的Products都加载完毕。。。。。。。。。。。。。。。。。。。。。");

            //加载Users搞定
            cdLock.Reset(2);
            for (int i = 0; i < 2; i++)
            {
                Task.Factory.StartNew(() =>
                {
                    LoadUser();
                });
            }
            cdLock.Wait();
            Console.WriteLine("所有的Users都加载完毕。。。。。。。。。。。。。。。。。。。。。");

            Console.WriteLine("所有的表数据都执行结束了。。。恭喜恭喜。。。。");
            Console.Read();
        }
        static void LoadOrder()
        {
            //书写具体的业务逻辑
            Console.WriteLine("当前LoadOrder正在加载中。。。{0}", Thread.CurrentThread.ManagedThreadId);
            //线程数量减1
            cdLock.Signal();

        }
        static void LoadProduct()
        {
            //书写具体的业务逻辑
            Console.WriteLine("当前LoadProduct正在加载中。。。{0}", Thread.CurrentThread.ManagedThreadId);
            //线程数量减1
            cdLock.Signal();
        }
        static void LoadUser()
        {
            //书写具体的业务逻辑
            Console.WriteLine("当前LoadUser正在加载中。。。{0}", Thread.CurrentThread.ManagedThreadId);
            //线程数量减1
            cdLock.Signal();
        }