本文共 8872 字，大约阅读时间需要 29 分钟。
读写锁的概念很简单，允许多个线程同时获取读锁，但同一时间只允许一个线程获得写锁，因此也称作共享-独占锁。在C#中，推荐使用ReaderWriterLockSlim类来完成读写锁的功能。
某些场合下，对一个对象的读取次数远远大于修改次数，如果只是简单的用lock方式加锁，则会影响读取的效率。而如果采用读写锁，则多个线程可以同时读取该对象，只有等到对象被写入锁占用的时候，才会阻塞。
简单的说，当某个线程进入读取模式时，此时其他线程依然能进入读取模式，假设此时一个线程要进入写入模式，那么他不得不被阻塞。直到读取模式退出为止。
同样的，如果某个线程进入了写入模式，那么其他线程无论是要写入还是读取，都是会被阻塞的。
进入写入/读取模式有2种方法：
EnterReadLock尝试进入写入模式锁定状态。
TryEnterReadLock(Int32) 尝试进入读取模式锁定状态，可以选择整数超时时间。
EnterWriteLock 尝试进入写入模式锁定状态。
TryEnterWriteLock(Int32) 尝试进入写入模式锁定状态，可以选择超时时间。
退出写入/读取模式有2种方法：
ExitReadLock 减少读取模式的递归计数，并在生成的计数为 0（零）时退出读取模式。
ExitWriteLock 减少写入模式的递归计数，并在生成的计数为 0（零）时退出写入模式。
下面演示一下用法：
| 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 | 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()); } } } |
可以看到3号线程和4号线程能够同时进入读模式，而5号线程过了5秒钟后（即3,4号线程退出读锁后），才能进入写模式。
把上述代码修改一下，先开启2个写模式的线程，然后在开启读模式线程，代码如下：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | 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()); } |
结果如下：
可以看到，3号线程和4号线程都要进入写模式，但是3号线程先占用写入锁，因此4号线程不得不等了10s后才进入。5号线程和6号线程需要占用读取锁，因此等4号线程退出写入锁后才能继续下去。
TryEnterReadLock和TryEnterWriteLock可以设置一个超时时间，运行到这句话的时候，线程会阻塞在此，如果此时能占用锁，那么返回true，如果到超时时间还未占用锁，那么返回false，放弃锁的占用，直接继续执行下面的代码。
EnterUpgradeableReadLock
ReaderWriterLockSlim类提供了可升级读模式，这种方式和读模式的区别在于它还有通过调用 EnterWriteLock 或 TryEnterWriteLock 方法升级为写入模式。 因为每次只能有一个线程处于可升级模式。进入可升级模式的线程，不会影响读取模式的线程，即当一个线程进入可升级模式，任意数量线程可以同时进入读取模式，不会阻塞。如果有多个线程已经在等待获取写入锁，那么运行EnterUpgradeableReadLock将会阻塞，直到那些线程超时或者退出写入锁。
下面代码演示了如何在可升级读模式下，升级到写入锁。
| 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 | 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 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 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 | public class Program { static private ReaderWriterLockSlim rwl = new ReaderWriterLockSlim(); static void Main( string [] args) { Stopwatch sw = new Stopwatch(); sw.Start(); List<Task> lstTask = new List<Task>(); for ( int i = 0; i < 500; i++) { if (i % 25 != 0) { var t = Task.Factory.StartNew(ReadSomething); lstTask.Add(t); } else { var t = Task.Factory.StartNew(WriteSomething); lstTask.Add(t); } } Task.WaitAll(lstTask.ToArray()); sw.Stop(); Console.WriteLine( "使用ReaderWriterLockSlim方式，耗时：" + sw.Elapsed); sw.Restart(); lstTask = new List<Task>(); for ( int i = 0; i < 500; i++) { if (i % 25 != 0) { var t = Task.Factory.StartNew(ReadSomething_lock); lstTask.Add(t); } else { var t = Task.Factory.StartNew(WriteSomething_lock); lstTask.Add(t); } } Task.WaitAll(lstTask.ToArray()); sw.Stop(); Console.WriteLine( "使用lock方式，耗时：" + sw.Elapsed); } static private object _lock1 = new object (); static public void ReadSomething_lock() { lock (_lock1) { //Console.WriteLine("{0} Thread ID {1} reading sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); Thread.Sleep(10); //模拟读取信息 //Console.WriteLine("{0} Thread ID {1} reading end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); } } static public void WriteSomething_lock() { lock (_lock1) { //Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); Thread.Sleep(100); //模拟写入信息 //Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); } } static public void ReadSomething() { rwl.EnterReadLock(); try { //Console.WriteLine("{0} Thread ID {1} reading sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); Thread.Sleep(10); //模拟读取信息 //Console.WriteLine("{0} Thread ID {1} reading end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); } finally { rwl.ExitReadLock(); } } static public void WriteSomething() { rwl.EnterWriteLock(); try { //Console.WriteLine("{0} Thread ID {1} writing sth...", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); Thread.Sleep(100); //模拟写入信息 //Console.WriteLine("{0} Thread ID {1} writing end.", DateTime.Now.ToString("hh:mm:ss fff"), Thread.CurrentThread.GetHashCode()); } finally { rwl.ExitWriteLock(); } } } |
上述代码，就500个Task，每个Task占用一个线程池线程，其中20个写入线程和480个读取线程，模拟操作。其中读取数据花10ms，写入操作花100ms，分别测试了对于lock方式和ReaderWriterLockSlim方式。可以做一个估算，对于ReaderWriterLockSlim，假设480个线程同时读取，那么消耗10ms，20个写入操作占用2000ms，因此所消耗时间2010ms，而对于普通的lock方式，由于都是独占性的，因此480个读取操作占时间4800ms+20个写入操作2000ms=6800ms。运行结果显示了性能提升明显。
本文转自cnn23711151CTO博客，原文链接： http://blog.51cto.com/cnn237111/1535687，如需转载请自行联系原作者