C#读写锁ReaderWriterLockSlim

https://blog.51cto.com/u_15077556/4245653

 

ReaderWriterLockSlim 读写锁
其实 ReaderWriterLockSlim  与  ReaderWriterLock  比较像

1.某个线程进入读取模式时，此时其他线程依然能进入读取模式。假设此时一个线程要进入写入模式，那么他不得不被阻塞。直到读取模式退出为止。

2.采用读写锁，则多个线程可以同时读取该对象，只有等到对象被写入锁占用的时候，才会阻塞。  写入锁占用时，读写锁都会被堵塞

3.如果某个线程进入了写入模式，那么其他线程无论是要写入还是读取，都是会被阻塞的。

进入写入/读取模式有2种方法：

EnterReadLock尝试进入写入模式锁定状态。

TryEnterReadLock(Int32) 尝试进入读取模式锁定状态，可以选择整数超时时间。

EnterWriteLock 尝试进入写入模式锁定状态。

TryEnterWriteLock(Int32) 尝试进入写入模式锁定状态，可以选择超时时间。

退出写入/读取模式有2种方法：

ExitReadLock 减少读取模式的递归计数，并在生成的计数为 0（零）时退出读取模式。

ExitWriteLock 减少写入模式的递归计数，并在生成的计数为 0（零）时退出写入模式。

 

 

 

public class Program
{
static private ReaderWriterLockSlim rwl = new ReaderWriterLockSlim();
static void Main(string[] args)
{
Thread t_read1 = new Thread(new ThreadStart(ReadSomething));
t_read1.Start();
Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read1.GetHashCode());
Thread t_read2 = new Thread(new ThreadStart(ReadSomething));
t_read2.Start();
Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read2.GetHashCode());
Thread t_write1 = new Thread(new ThreadStart(WriteSomething));
t_write1.Start();
Console.WriteLine("{0} Create Thread ID {1} , Start WriteSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_write1.GetHashCode());
}
static public void ReadSomething()
{
Console.WriteLine("{0} Thread ID {1} Begin EnterReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
rwl.EnterReadLock();
try
{
Console.WriteLine("{0} Thread ID {1} reading sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
Thread.Sleep(5000);//模拟读取信息
Console.WriteLine("{0} Thread ID {1} reading end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
}
finally
{
rwl.ExitReadLock();
Console.WriteLine("{0} Thread ID {1} ExitReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
}
}
static public void WriteSomething()
{
Console.WriteLine("{0} Thread ID {1} Begin EnterWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
rwl.EnterWriteLock();
try
{
Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
Thread.Sleep(10000);//模拟写入信息
Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
}
finally
{
rwl.ExitWriteLock();
Console.WriteLine("{0} Thread ID {1} ExitWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
}
}
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.

　　

 

 可以看到3号线程和4号线程能够同时进入读模式，而5号线程过了5秒钟后（即3,4号线程退出读锁后），才能进入写模式。

把上述代码修改一下，先开启2个写模式的线程，然后在开启读模式线程，代码如下：

 

 

static void Main(string[] args)
{
Thread t_write1 = new Thread(new ThreadStart(WriteSomething));
t_write1.Start();
Console.WriteLine("{0} Create Thread ID {1} , Start WriteSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_write1.GetHashCode());
Thread t_write2 = new Thread(new ThreadStart(WriteSomething));
t_write2.Start();
Console.WriteLine("{0} Create Thread ID {1} , Start WriteSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_write2.GetHashCode());
Thread t_read1 = new Thread(new ThreadStart(ReadSomething));
t_read1.Start();
Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read1.GetHashCode());
Thread t_read2 = new Thread(new ThreadStart(ReadSomething));
t_read2.Start();
Console.WriteLine("{0} Create Thread ID {1} , Start ReadSomething", DateTime.Now.ToString("hh:mm:ss fff"), t_read2.GetHashCode());
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

　　

 

 3号线程和4号线程都要进入写模式，但是3号线程先占用写入锁，因此4号线程不得不等了10s后才进入。5号线程和6号线程需要占用读取锁，因此等4号线程退出写入锁后才能继续下去。

 

 

 

TryEnterReadLock和TryEnterWriteLock可以设置一个超时时间，运行到这句话的时候，线程会阻塞在此，如果此时能占用锁，那么返回true，如果到超时时间还未占用锁，那么返回false，放弃锁的占用，直接继续执行下面的代码。

 

 

 

 

 

static void Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
//Console.WriteLine(Thread.CurrentThread.GetHashCode() + "begin");
//callMethod();
//Console.WriteLine(Thread.CurrentThread.GetHashCode() + "end");

Task[] tasks = new Task[5];
tasks[0] = Task.Factory.StartNew(WriteBook);
tasks[1] = Task.Factory.StartNew(ReadBook);
tasks[2] = Task.Factory.StartNew(WriteBook);
tasks[3] = Task.Factory.StartNew(ReadBook);
tasks[4] = Task.Factory.StartNew(WriteBook);

//var task=Task.Factory.StartNew(ReadBook);
//task.Start();
//Task.WaitAll(tasks);

Console.ReadKey();
}
static private ReaderWriterLockSlim rwl = new ReaderWriterLockSlim();
// 测试 try超时

public static void ReadBook()
{
Console.WriteLine(Thread.CurrentThread.GetHashCode()+" Begin Read");

if (rwl.TryEnterReadLock(3000))
{
try
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Enter Read");
Thread.Sleep(5000);
Console.WriteLine(Thread.CurrentThread.GetHashCode() + "Read 获取读取锁成功");
Console.WriteLine(Thread.CurrentThread.GetHashCode() + "Read XXXXXXX");
}
finally
{
rwl.ExitReadLock();
}
}
else
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() + "Read 获取写入锁失败");
}

Console.WriteLine(Thread.CurrentThread.GetHashCode()+" End Read");
}
public static void WriteBook()
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Begin Write");

if (rwl.TryEnterWriteLock(3000))
{
try
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Enter Write");
Thread.Sleep(1000);
Console.WriteLine(Thread.CurrentThread.GetHashCode() + "Write 获取写入锁成功");
Console.WriteLine(Thread.CurrentThread.GetHashCode() + "Write XXXXXXX");
}
finally
{
rwl.ExitWriteLock();
}
}
else
{
Console.WriteLine(Thread.CurrentThread.GetHashCode() + "Write 获取写入锁失败");
}

Console.WriteLine(Thread.CurrentThread.GetHashCode() + " End Write");
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.

　　

 

 

EnterUpgradeableReadLock

ReaderWriterLockSlim类提供了可升级读模式，这种方式和读模式的区别在于它还有通过调用 EnterWriteLock 或 TryEnterWriteLock 方法升级为写入模式。 因为每次只能有一个线程处于可升级模式。进入可升级模式的线程，不会影响读取模式的线程，即当一个线程进入可升级模式，任意数量线程可以同时进入读取模式，不会阻塞。如果有多个线程已经在等待获取写入锁，那么运行EnterUpgradeableReadLock将会阻塞，直到那些线程超时或者退出写入锁。

 

 

static public void UpgradeableRead()
{
Console.WriteLine("{0} Thread ID {1} Begin EnterUpgradeableReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
rwl.EnterUpgradeableReadLock();
try
{
Console.WriteLine("{0} Thread ID {1} doing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
Console.WriteLine("{0} Thread ID {1} Begin EnterWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
rwl.EnterWriteLock();
try
{
Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
Thread.Sleep(10000);//模拟写入信息
Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
}
finally
{
rwl.ExitWriteLock();
Console.WriteLine("{0} Thread ID {1} ExitWriteLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
}
Thread.Sleep(10000);//模拟读取信息
Console.WriteLine("{0} Thread ID {1} doing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
}
finally
{
rwl.ExitUpgradeableReadLock();
Console.WriteLine("{0} Thread ID {1} ExitUpgradeableReadLock...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode());
}
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.

　　

有一个官方的例子

 

 

登录后复制
private ReaderWriterLockSlim cacheLock = new ReaderWriterLockSlim();
private Dictionary<int, string> innerCache = new Dictionary<int, string>();

public AddOrUpdateStatus AddOrUpdate(int key, string value)
{
cacheLock.EnterUpgradeableReadLock();
try
{
string result = null;
if (innerCache.TryGetValue(key, out result))
{
if (result == value)
{
return AddOrUpdateStatus.Unchanged;
}
else
{
cacheLock.EnterWriteLock();
try
{
innerCache[key] = value;
}
finally
{
cacheLock.ExitWriteLock();
}
return AddOrUpdateStatus.Updated;
}
}
else
{
cacheLock.EnterWriteLock();
try
{
innerCache.Add(key, value);
}
finally
{
cacheLock.ExitWriteLock();
}
return AddOrUpdateStatus.Added;
}
}
finally
{
cacheLock.ExitUpgradeableReadLock();
}
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.

　　

递归

使用允许递归锁的构造方法（即new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion)）构造ReaderWriterLockSlim实例

如何判断代码逻辑里会触发递归锁呢，抓住两个要点“同一线程（即ManageThreadId一样）”和“同一个锁”，在线程池里运行的时候，由于可以重用工作线程，很容易触发递归锁的问题，比如这样：线程池线程1获取到UpgradeableReadLock锁后由于后面代码里有长时等待任务，调度器可能调度线程1运行队列里的另一个同样代码的任务，这时由于代码一样线程1再次申请获取UpgradeableReadLock锁（因为上一次他已经获取到该UpgradeableReadLock锁了），就会报错了
-----------------------------------
C#读写锁ReaderWriterLockSlim
https://blog.51cto.com/u_15077556/4245653