ReaderWriterLockSlim 类
表示用于管理资源访问的锁定状态，可实现多线程读取或进行独占式写入访问。
ps:该类在.NET3.5中提供,如需要在2.0中使用请换ReaderWriterLock,用法差不多改了写方法名,MSDN中说ReaderWriterLockSlim性能比较高
主要属性,方法
IsReadLockHeld 获取一个值，该值指示当前线程是否已进入读取模式的锁定状态。 IsWriteLockHeld 获取一个值，该值指示当前线程是否已进入写入模式的锁定状态。
当然还有其他很多方法,比如EnterUpgradeableReadLock进入可以升级到写入模式的读取模式..
不过我需要封装的对象相对来说较为简单,所以不需要用这些额外的方法和属性,有兴趣的可以自己去研究下
应用
private object _Lock = new object();
private void Read()
{
lock (_Lock)
{
//具体方法实现
}
}
private void Write()
{
lock (_Lock)
{
//具体方法实现
}
}
private ReaderWriterLockSlim _LockSlim = new ReaderWriterLockSlim();
private void Read()
{
try
{
_LockSlim.EnterReadLock();
//具体方法实现
}
finally
{
_LockSlim.ExitReadLock();
}
}
private void Write()
{
try
{
_LockSlim.EnterWriteLock();
//具体方法实现
}
finally
{
_LockSlim.ExitWriteLock();
}
}
从性能的角度来说,肯定是读写锁分离更好了,特别是大多数场合(读取操作远远多余写入操作)
从可读性和代码美观度来说,就是上面的lock要简洁的多了,维护起来也更清晰
所以我希望重新封装ReaderWriterLockSlim,当然我第一想到的就是using了,利用using语法糖的特性封装一个新的对象
封装
由于是利用的using的语法,所以我直接取名叫UsingLock,简单好记
using System;
using System.Threading;
namespace blqw
{
/// <summary> 使用using代替lock操作的对象,可指定写入和读取锁定模式
/// </summary>
public class UsingLock<T>
{
#region 内部类
/// <summary> 利用IDisposable的using语法糖方便的释放锁定操作
/// <para>内部类</para>
/// </summary>
private struct Lock : IDisposable
{
/// <summary> 读写锁对象
/// </summary>
private ReaderWriterLockSlim _Lock;
/// <summary> 是否为写入模式
/// </summary>
private bool _IsWrite;
/// <summary> 利用IDisposable的using语法糖方便的释放锁定操作
/// <para>构造函数</para>
/// </summary>
/// <param name="rwl">读写锁</param>
/// <param name="isWrite">写入模式为true,读取模式为false</param>
public Lock(ReaderWriterLockSlim rwl, bool isWrite)
{
_Lock = rwl;
_IsWrite = isWrite;
}
/// <summary> 释放对象时退出指定锁定模式
/// </summary>
public void Dispose()
{
if (_IsWrite)
{
if (_Lock.IsWriteLockHeld)
{
_Lock.ExitWriteLock();
}
}
else
{
if (_Lock.IsReadLockHeld)
{
_Lock.ExitReadLock();
}
}
}
}
/// <summary> 空的可释放对象,免去了调用时需要判断是否为null的问题
/// <para>内部类</para>
/// </summary>
private class Disposable : IDisposable
{
/// <summary> 空的可释放对象
/// </summary>
public static readonly Disposable Empty = new Disposable();
/// <summary> 空的释放方法
/// </summary>
public void Dispose() { }
}
#endregion
/// <summary> 读写锁
/// </summary>
private ReaderWriterLockSlim _LockSlim = new ReaderWriterLockSlim();
/// <summary> 保存数据
/// </summary>
private T _Data;
/// <summary> 使用using代替lock操作的对象,可指定写入和读取锁定模式
/// <para>构造函数</para>
/// </summary>
public UsingLock()
{
Enabled = true;
}
/// <summary> 使用using代替lock操作的对象,可指定写入和读取锁定模式
/// <para>构造函数</para>
/// <param name="data">为Data属性设置初始值</param>
public UsingLock(T data)
{
Enabled = true;
_Data = data;
}
/// <summary> 获取或设置当前对象中保存数据的值
/// </summary>
/// <exception cref="MemberAccessException">获取数据时未进入读取或写入锁定模式</exception>
/// <exception cref="MemberAccessException">设置数据时未进入写入锁定模式</exception>
public T Data
{
get
{
if (_LockSlim.IsReadLockHeld || _LockSlim.IsWriteLockHeld)
{
return _Data;
}
throw new MemberAccessException("请先进入读取或写入锁定模式再进行操作");
}
set
{
if (_LockSlim.IsWriteLockHeld == false)
{
throw new MemberAccessException("只有写入模式中才能改变Data的值");
}
_Data = value;
}
}
/// <summary> 是否启用,当该值为false时,Read()和Write()方法将返回 Disposable.Empty
/// </summary>
public bool Enabled { get; set; }
/// <summary> 进入读取锁定模式,该模式下允许多个读操作同时进行
/// <para>退出读锁请将返回对象释放,建议使用using语块</para>
/// <para>Enabled为false时,返回Disposable.Empty;</para>
/// <para>在读取或写入锁定模式下重复执行,返回Disposable.Empty;</para>
/// </summary>
public IDisposable Read()
{
if (Enabled == false || _LockSlim.IsReadLockHeld || _LockSlim.IsWriteLockHeld)
{
return Disposable.Empty;
}
else
{
_LockSlim.EnterReadLock();
return new Lock(_LockSlim, false);
}
}
/// <summary> 进入写入锁定模式,该模式下只允许同时执行一个读操作
/// <para>退出读锁请将返回对象释放,建议使用using语块</para>
/// <para>Enabled为false时,返回Disposable.Empty;</para>
/// <para>在写入锁定模式下重复执行,返回Disposable.Empty;</para>
/// </summary>
/// <exception cref="NotImplementedException">读取模式下不能进入写入锁定状态</exception>
public IDisposable Write()
{
if (Enabled == false || _LockSlim.IsWriteLockHeld)
{
return Disposable.Empty;
}
else if (_LockSlim.IsReadLockHeld)
{
throw new NotImplementedException("读取模式下不能进入写入锁定状态");
}
else
{
_LockSlim.EnterWriteLock();
return new Lock(_LockSlim, true);
}
}
}
}
Data UsingLock中可以保存一个数据,由当前线程中的环境判断是否可以读取或设置该对象
使用场合
/// <summary> 假设有这样一个队列系统
/// </summary>
class MyQueue:IEnumerable<string>
{
List<string> _List;
UsingLock<object> _Lock;
public MyQueue(IEnumerable<string> strings)
{
_List = new List<string>(strings);
_Lock = new UsingLock<object>();
}
/// <summary> 获取第一个元素.并且从集合中删除
/// </summary>
public string LootFirst()
{
using (_Lock.Write())
{
if (_List.Count == 0)
{
_Lock.Enabled = false;
return null;
}
var s = _List[0];
_List.RemoveAt(0);
return s;
}
}
public int Count { get { return _List.Count; } }
/// <summary> 枚举当前集合的元素
/// </summary>
public IEnumerator<string> GetEnumerator()
{
using (_Lock.Read())
{
foreach (var item in _List)
{
yield return item;
}
}
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
我这里假设了一个队列系统,把最容易出现问题的修改集合和枚举集合2个操作公开出来,方便在多线程中测试效果
static void Main(string[] args)
{
//建立一个字符串集合,总数为1000
List<string> list = new List<string>(1000);
for (int i = 0; i < list.Capacity; i++)
{
list.Add("字符串:" + i);
}
MyQueue mq = new MyQueue(list);
//保存最后一个值,等下用于做比较
string last = list[list.Count - 1];
//开启1000个线程,同时执行LootFirst方法,并打印出结果
for (int i = 0; i < list.Capacity; i++)
{
ThreadPool.QueueUserWorkItem(o =>
{
Console.WriteLine(mq.LootFirst());
});
}
//在主线程中不停调用mq的遍历方法,这样的操作是很容易出现线程争抢资源的,如果没有锁定访问机制,就会出现异常
while (mq.Count > 0)
{
foreach (var item in mq)
{
//如果最后一个值还在,就输出 "还在"
if (item == last)
{
Console.WriteLine("还在");
}
}
}
}
Release模式下也是很轻松就跑完了,证明访问的同步控制部分是可以正常工作的
使用详细说明
语法上是不是跟lock比较类似了?Enabled属性的作用在这里就可见一斑了
对比无lock
对比原始单一lock
来源：https://www.cnblogs.com/feige/p/6044647.html