C#读写锁实例分析

今天小编给大家分享一下C#读写锁实例分析的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。

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

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

以上就是“C#读写锁实例分析”这篇文章的所有内容，感谢各位的阅读！相信大家阅读完这篇文章都有很大的收获，小编每天都会为大家更新不同的知识，如果还想学习更多的知识，请关注编程网行业资讯频道。