C#多线程(10)：读写锁

ReaderWriterLockSlim
ReaderWriterLockSlim

本篇的内容主要是介绍 ReaderWriterLockSlim 类，来实现多线程下的读写分离。

ReaderWriterLockSlim

ReaderWriterLock 类：定义支持单个写线程和多个读线程的锁。

ReaderWriterLockSlim 类：表示用于管理资源访问的锁定状态，可实现多线程读取或进行独占式写入访问。

两者的 API 十分接近，而且 ReaderWriterLockSlim 相对 ReaderWriterLock 来说更加安全。因此本文主要讲解 ReaderWriterLockSlim 。

两者都是实现多个线程可同时读取、只允许一个线程写入的类。

ReaderWriterLockSlim

老规矩，先大概了解一下 ReaderWriterLockSlim 常用的方法。

常用方法

方法	说明
EnterReadLock()	尝试进入读取模式锁定状态。
EnterUpgradeableReadLock()	尝试进入可升级模式锁定状态。
EnterWriteLock()	尝试进入写入模式锁定状态。
ExitReadLock()	减少读取模式的递归计数，并在生成的计数为 0（零）时退出读取模式。
ExitUpgradeableReadLock()	减少可升级模式的递归计数，并在生成的计数为 0（零）时退出可升级模式。
ExitWriteLock()	减少写入模式的递归计数，并在生成的计数为 0（零）时退出写入模式。
TryEnterReadLock(Int32)	尝试进入读取模式锁定状态，可以选择整数超时时间。
TryEnterReadLock(TimeSpan)	尝试进入读取模式锁定状态，可以选择超时时间。
TryEnterUpgradeableReadLock(Int32)	尝试进入可升级模式锁定状态，可以选择超时时间。
TryEnterUpgradeableReadLock(TimeSpan)	尝试进入可升级模式锁定状态，可以选择超时时间。
TryEnterWriteLock(Int32)	尝试进入写入模式锁定状态，可以选择超时时间。
TryEnterWriteLock(TimeSpan)	尝试进入写入模式锁定状态，可以选择超时时间。

ReaderWriterLockSlim 的读、写入锁模板如下：

        private static ReaderWriterLockSlim toolLock = new ReaderWriterLockSlim();
		// 读
        private T Read()
        {
            try
            {
                toolLock.EnterReadLock();           // 获取读取锁
                return obj;
            }
            catch { }
            finally
            {
                toolLock.ExitReadLock();            // 释放读取锁
            }
            return default;
        }
        // 写
        public void Write(int key, int value)
        {
            try
            {
                toolLock.EnterUpgradeableReadLock();
                try
                {
                    toolLock.EnterWriteLock();
                    /*
                     *
                    */
                }
                catch
                {
                }
                finally
                {
                    toolLock.ExitWriteLock();
                }
            }
            catch { }
            finally
            {
                toolLock.ExitUpgradeableReadLock();
            }
        }

订单系统示例

这里来模拟一个简单粗糙的订单系统。

开始编写代码前，先来了解一些方法的具体使用。

EnterReadLock() / TryEnterReadLock 和 ExitReadLock() 成对出现。

EnterWriteLock() / TryEnterWriteLock() 和 ExitWriteLock() 成对出现。

EnterUpgradeableReadLock() 进入可升级的读模式锁定状态。

EnterReadLock() 使用 EnterUpgradeableReadLock() 进入升级状态，在恰当时间点通过 EnterWriteLock() 进入写模式。（也可以倒过来）

定义三个变量：

ReaderWriterLockSlim 多线程读写锁；

MaxId 当前订单 Id 的最大值；

orders 订单表；

        private static ReaderWriterLockSlim tool = new ReaderWriterLockSlim();   // 读写锁
        private static int MaxId = 1;
        public static List<DoWorkModel> orders = new List<DoWorkModel>();       // 订单表

        // 订单模型
        public class DoWorkModel
        {
            public int Id { get; set; }     // 订单号
            public string UserName { get; set; }    // 客户名称
            public DateTime DateTime { get; set; }  // 创建时间
        }

然后实现查询和创建订单的两个方法。

分页查询订单：

在读取前使用 EnterReadLock() 获取锁；

读取完毕后，使用 ExitReadLock() 释放锁。

这样能够在多线程环境下保证每次读取都是最新的值。

        // 分页查询订单
        private static DoWorkModel[] DoSelect(int pageNo, int pageSize)
        {
            try
            {
                DoWorkModel[] doWorks;
                tool.EnterReadLock();           // 获取读取锁
                doWorks = orders.Skip((pageNo - 1) * pageSize).Take(pageSize).ToArray();
                return doWorks;
            }
            catch { }
            finally
            {
                tool.ExitReadLock();            // 释放读取锁
            }
            return default;
        }

创建订单：

创建订单的信息十分简单，知道用户名和创建时间就行。

订单系统要保证的时每个 Id 都是唯一的(实际情况应该用Guid)，这里为了演示读写锁，设置为数字。

在多线程环境下，我们不使用 Interlocked.Increment() ，而是直接使用 += 1，因为有读写锁的存在，所以操作也是原则性的。

        // 创建订单
        private static DoWorkModel DoCreate(string userName, DateTime time)
        {
            try
            {
                tool.EnterUpgradeableReadLock();        // 升级
                try
                {
                    tool.EnterWriteLock();              // 获取写入锁
                    // 写入订单
                    MaxId += 1;                         // Interlocked.Increment(ref MaxId);
                    DoWorkModel model = new DoWorkModel
                    {
                        Id = MaxId,
                        UserName = userName,
                        DateTime = time
                    };
                    orders.Add(model);
                    return model;
                }
                catch { }
                finally
                {
                    tool.ExitWriteLock();               // 释放写入锁
                }
            }
            catch { }
            finally
            {
                tool.ExitUpgradeableReadLock();         // 降级
            }
            return default;
        }

Main 方法中：

开 5 个线程，不断地读，开 2 个线程不断地创建订单。线程创建订单时是没有设置 Thread.Sleep() 的，因此运行速度十分快。

Main 方法里面的代码没有什么意义。

        static void Main(string[] args)
        {
            // 5个线程读
            for (int i = 0; i < 5; i++)
            {
                new Thread(() =>
                {
                    while (true)
                    {
                        var result = DoSelect(1, MaxId);
                        if (result is null)
                        {
                            Console.WriteLine("获取失败");
                            continue;
                        }
                        foreach (var item in result)
                        {
                            Console.Write($"{item.Id}|");
                        }
                        Console.WriteLine("\n");
                        Thread.Sleep(1000);
                    }
                }).Start();
            }
            for (int i = 0; i < 2; i++)
            {
                new Thread(() =>
                {
                    while(true)
                    {
                        var result = DoCreate((new Random().Next(0, 100)).ToString(), DateTime.Now);      // 模拟生成订单
                        if (result is null)
                            Console.WriteLine("创建失败");
                        else Console.WriteLine("创建成功");
                    }
                }).Start();
            }
        }

在 ASP.NET Core 中，则可以利用读写锁，解决多用户同时发送 HTTP 请求带来的数据库读写问题。

这里就不做示例了。

如果另一个线程发生问题，导致迟迟不能交出写入锁，那么可能会导致其它线程无限等待。

那么可以使用 TryEnterWriteLock() 并且设置等待时间，避免阻塞时间过长。

bool isGet = tool.TryEnterWriteLock(500);

并发字典写示例

因为理论的东西，笔者这里不会说太多，主要就是先掌握一些 API(方法、属性) 的使用，然后简单写出示例，后面再慢慢深入了解底层原理。

这里来写一个多线程共享使用字典(Dictionary)的使用示例。

增加两个静态变量：

        private static ReaderWriterLockSlim toolLock = new ReaderWriterLockSlim();
        private static Dictionary<int, int> dict = new Dictionary<int, int>();

实现一个写操作：

        public static void Write(int key, int value)
        {
            try
            {
                // 升级状态
                toolLock.EnterUpgradeableReadLock();
                // 读，检查是否存在
                if (dict.ContainsKey(key))
                    return;
                try
                {
                    // 进入写状态
                    toolLock.EnterWriteLock();
                    dict.Add(key,value);
                }
                finally
                {
                    toolLock.ExitWriteLock();
                }
            }
            finally
            {
                toolLock.ExitUpgradeableReadLock();
            }
        }

上面没有 catch { } 是为了更好观察代码，因为使用了读写锁，理论上不应该出现问题的。

模拟五个线程同时写入字典，由于不是原子操作，所以 sum 的值有些时候会出现重复值。

原子操作请参考：https://www.cnblogs.com/whuanle/p/12724371.html#1，出现问题

        private static int sum = 0;
        public static void AddOne()
        {
            for (int i = 0; i < 100_0000; i++)
            {
                sum += 1;
                Write(sum,sum);
            }
        }
        static void Main(string[] args)
        {
            for (int i = 0; i < 5; i++)
                new Thread(() => { AddOne(); }).Start();
            Console.ReadKey();
        }

ReaderWriterLock

大多数情况下都是推荐 ReaderWriterLockSlim 的，而且两者的使用方法十分接近。

例如 AcquireReaderLock 是获取读锁，AcquireWriterLock 获取写锁。使用对应的方法即可替换 ReaderWriterLockSlim 中的示例。

这里就不对 ReaderWriterLock 进行赘述了。

ReaderWriterLock 的常用方法如下：

方法	说明
AcquireReaderLock(Int32)	使用一个 Int32 超时值获取读线程锁。
AcquireReaderLock(TimeSpan)	使用一个 TimeSpan 超时值获取读线程锁。
AcquireWriterLock(Int32)	使用一个 Int32 超时值获取写线程锁。
AcquireWriterLock(TimeSpan)	使用一个 TimeSpan 超时值获取写线程锁。
AnyWritersSince(Int32)	指示获取序列号之后是否已将写线程锁授予某个线程。
DowngradeFromWriterLock(LockCookie)	将线程的锁状态还原为调用 UpgradeToWriterLock(Int32) 前的状态。
ReleaseLock()	释放锁，不管线程获取锁的次数如何。
ReleaseReaderLock()	减少锁计数。
ReleaseWriterLock()	减少写线程锁上的锁计数。
RestoreLock(LockCookie)	将线程的锁状态还原为调用 ReleaseLock() 前的状态。
UpgradeToWriterLock(Int32)	使用一个 Int32 超时值将读线程锁升级为写线程锁。
UpgradeToWriterLock(TimeSpan)	使用一个 `TimeSpan` 超时值将读线程锁升级为写线程锁。

官方示例可以看：

https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.readerwriterlock?view=netcore-3.1#examples