C#多线程系列之读写锁-ReaderWriterLockSlim 类

青旅半醒 2024-04-01 19:04 72阅读 0赞

### C\#多线程系列之读写锁 ###

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

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

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

两者的 API 十分接近，而且 ReaderWriterLockSlim 相对 ReaderWriterLock 来说 更加安全。因此本文主要讲解 ReaderWriterLockSlim 。  
两者都是实现多个线程可同时读取、只允许一个线程写入的类。

ReaderWriterLockSlim  
先大概了解一下 ReaderWriterLockSlim 常用的方法。

**常用方法**  
![在这里插入图片描述][a19bfb1ce76f478faa3cab13c45c1da9.png]  
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;
            }

**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 的值有些时候会出现重复值。

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 的常用方法如下：  
![在这里插入图片描述][19be4464fcf34b549aae213d321274ad.png]  
[请看官方示例][Link 1]  
点个赞收藏一下再走呗！  
![请添加图片描述][158fa6546f1c495e9350841c0bb8b2e6.webp]

[a19bfb1ce76f478faa3cab13c45c1da9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/abdf7e4bc12441b79779402b7fbb2601.png
[19be4464fcf34b549aae213d321274ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e35ae208a9e942349c13a03199b16eff.png
[Link 1]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.readerwriterlock?view=netcore-3.1#examples
[158fa6546f1c495e9350841c0bb8b2e6.webp]: https://img-blog.csdnimg.cn/158fa6546f1c495e9350841c0bb8b2e6.webp