C#多线程系列之读写锁

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

ReaderWriterLockSlim

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

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

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

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

ReaderWriterLockSlim

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

常用方法

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.jb51.net/article/237310.htm

        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 的常用方法如下：

官方示例可以看：

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

到此这篇关于C#多线程系列之读写锁的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。