2.9 读写锁

ReaderWriterLock、ReaderWriterLockSlim 都是 C# 中设置读写锁的手段，本篇的内容主要是介绍 ReaderWriterLockSlim 类，来实现多线程下的读写分离，由于两者很接近，因此本章就不讨论 ReaderWriterLock 了。

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();
    }
}

使用 ReaderWriterLockSlim 时，需要注意释放读锁或写锁。

订单系统示例

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

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

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

官方示例可以看：

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