第十一节：深究用户模式锁的使用场景(异变结构、互锁、旋转锁)

一. 锁机制的背景介绍

　　本章节，将结合多线程来介绍锁机制， 那么问题来了，什么是锁呢？ 为什么需要锁？ 为什么要结合多线程来介绍锁呢？锁的使用场景又是什么呢？ DotNet中又有哪些锁呢？

　　在接下来的几个章节中，将陆续解答这些问题。

PS：

　　多个线程对一个共享资源进行使用的时候，会出问题, 比如实际的业务场景，入库和出库操作同时进行，库存量就会存在并发问题。所以锁就是用来解决多线程资源竞用的问题。

　　Net领域中，锁机制非常多，比如：时间锁、信号量、互斥锁、读写锁、互锁、异变结构，主要我们可以把他们划分为三大类：

　　　　①.用户模式锁：就是通过一些cpu指令或者一个死循环,来达到达到线程的等待和休眠。
　　　　②.内核模式锁：就是调用win32底层的代码，来实现thread的各种操作。
　　　　③.混合锁：用户模式+内核模式

　　其中用户模式锁又分为这么几类：异变结构、互锁和旋转锁。

二. 异变结构

背景：一个线程读，一个线程写，在release模式下会出现bug，导致主线程无法执行，原因在前面章节已经介绍过了。

　　方式一：利用MemoryBarrier方法进行处理 。（前面章节已介绍）

　　方式二：利用VolatileRead/Write方法进行处理。 (前面章节已介绍)

　　方式三：volatile关键字进行处理，我的read和write都是从memrory中读取，读取的都是最新的。（下面的案例使用volatile关键字后，主线程可以执行）

 代码实践：

            public static volatile bool isStop = false;
                //使用Volatile关键字处理        
                var t = new Thread(() =>
                {
                    var isSuccess = false;
                    while (!isStop)
                    {
                        isSuccess = !isSuccess;
                    }
                });
                t.Start();
                Thread.Sleep(1000);
                isStop = true;
                t.Join();
                Console.WriteLine("主线程执行结束！");
                Console.ReadLine();
 

代码结论：使用volatile关键字进行修饰，解决共享资源的竞用问题。

三. 互锁

　　互锁结构（Interlocked类），常用的方法有：

　　　　* Increment：自增操作

　　　　* Decrement：自减操作

　　　　* Add： 增加指定的值

　　　　* Exchange： 赋值

　　　　* CompareExchange： 比较赋值

 代码实践：

            {
                //1. 自增
                {
                    int a = 1;
                    Interlocked.Increment(ref a);
                    Console.WriteLine("自增后的数据为:{0}", a);
                }
                //2. 自减
                {
                    int b = 2;
                    Interlocked.Decrement(ref b);
                    Console.WriteLine("自减后的数据为:{0}", b);
                }
                //3. 增加操作
                {
                    int c = 3;
                    Interlocked.Add(ref c, 4);
                    Console.WriteLine("增加后的数据为:{0}", c);

                }
                //4. 赋值操作
                {
                    int d = 4;
                    Interlocked.Exchange(ref d, 55);
                    Console.WriteLine("赋值后的数据为:{0}", d);

                }
                //5. 比较赋值
                {
                    //Interlocked.CompareExchange(ref num1, sum, num2);  // num1==num2 ; num1=sum;
                    int ee = 5;
                    Interlocked.CompareExchange(ref ee, 15, 5);
                    Console.WriteLine("比较赋值后的数据为:{0}", ee);

                    Interlocked.CompareExchange(ref ee, 100, 15);
                    Console.WriteLine("比较赋值后的数据为:{0}", ee);

                }

            }

代码结果：

 

四. 旋转锁

　　旋转锁(SpinLock)， 特殊的业务逻辑让thread在用户模式下进行自选，欺骗cpu当前thread正在运行中。

 　　SpinLock类有两个核心方法，分别是：Enter和Exit方法。

 代码实践：

            {
                //下面代码的结果：num从0-249，且是有序的。
                //如果把旋转锁去掉，num将没有任何顺序
                for (int i = 0; i < 5; i++)
                {
                    Task.Factory.StartNew(() =>
                    {
                        for (int j = 0; j < 50; j++)
                        {
                            try
                            {
                                var b = false;
                                sl.Enter(ref b);
                                Console.WriteLine(num++);
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine(ex.Message);
                            }
                            finally
                            {
                                sl.Exit();
                            }
                        }
                    });
                }
            }

代码结果：下面代码的结果：num从0-249，且是有序的；如果将旋转锁的代码去掉，num的输出将没有任何顺序可言。