[.net 多线程 ]ReaderWriterLock

ReaderWriterLock 用于同步对资源的访问。在任一特定时刻，它允许多个线程同时进行读访问，或者允许单个线程进行写访问。在资源不经常发生更改的情况下，ReaderWriterLock 所提供的吞吐量比简单的一次只允许一个线程的锁（如 Monitor）更高。

在多数访问为读访问，而写访问频率较低、持续时间也比较短的情况下，ReaderWriterLock 的性能最好。多个读线程与单个写线程交替进行操作，所以读线程和写线程都不会长时间阻止。

注意 
长时间持有读线程锁或写线程锁会使其他线程发生饥饿 (starve)。为了得到最好的性能，需要考虑重新构造应用程序以将写访问的持续时间减少到最小。

一个线程可以持有读线程锁或写线程锁，但是不能同时持有两者。若要获取写线程锁，请使用 UpgradeToWriterLock 和 DowngradeFromWriterLock，而不要通过释放读线程锁的方式获取。

递归锁请求会增加锁上的锁计数。

读线程和写线程将分别排入各自的队列。当线程释放写线程锁时，此刻读线程队列中的所有等待线程都将被授予读线程锁；当已释放所有读线程锁时，写线程队列中处于等待状态的下一个线程（如果存在）将被授予写线程锁，依此类推。换句话说，ReaderWriterLock 在一组读线程和一个写线程之间交替进行操作。

当写线程队列中有一个线程在等待活动读线程锁被释放时，请求新的读线程锁的线程会排入读线程队列。即使它们能和现有的阅读器锁持有者共享并发访问，也不会给它们的请求授予权限；这有助于防止编写器被阅读器无限期阻止。

大多数在 ReaderWriterLock 上获取锁的方法都采用超时值。使用超时可以避免应用程序中出现死锁。例如，某个线程可能获取了一个资源上的写线程锁，然后请求第二个资源上的读线程锁；同时，另一个线程获取了第二个资源上的写线程锁，并请求第一个资源上的读线程锁。如果不使用超时，这两个线程将出现死锁。

如果超时间隔过期并且没有授予锁请求，则此方法通过引发 ApplicationException 将控制返回给调用线程。线程可以捕捉此异常并确定下一步要进行的操作。

 static void Main(string[] args)
         {
             Dictionary<int, string> dic = new Dictionary<int, string>();
             ReaderWriterLockSlim lockSlim = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
             Task.Factory.StartNew(() =>
             {
                 int key = ;
                 while (key <= )
                 {
                     Thread.Sleep();
                     string info = $"写线程：{DateTime.Now.ToString("hhMMss-fff")}";
                     if (lockSlim.TryEnterWriteLock())
                     {
                         try
                         {
                             dic.Add(key++, info);
                             Console.WriteLine(info);
                         }
                         catch (Exception ex)
                         {
                             ;
                         }
                         finally
                         {
                             Console.WriteLine($"释放 {info}");
                             lockSlim.ExitWriteLock();
                         }
                     }
                 }
             });
             Task.Factory.StartNew(() =>
             {
                 while (true)
                 {
                     Thread.Sleep();
                     int key = ;
                     if (lockSlim.TryEnterReadLock())
                     {
                         try
                         {
                             while (key < dic.Count)
                             {
                                 Console.WriteLine($"读线程1：{dic[key++]}");
                             }
                         }
                         catch (Exception ex)
                         {
                             ;
                         }
                         finally
                         {
                             lockSlim.ExitReadLock();
                         }
                     }
                 }
             });
             Task.Factory.StartNew(() =>
             {
                 while (true)
                 {
                     Thread.Sleep();
                     int key = ;
                     if (lockSlim.TryEnterReadLock())
                     {
                         try
                         {
                             while (key < dic.Count)
                             {
                                 Console.WriteLine($"读线程2：{dic[key++]}");
                             }
                         }
                         catch (Exception ex)
                         {
                             ;
                         }
                         finally
                         {
                             lockSlim.ExitReadLock();
                         }
                     }
                 }
             });
             Task.Factory.StartNew(() =>
             {
                 while (true)
                 {
                     Thread.Sleep();
                     int key = ;
                     if (lockSlim.TryEnterReadLock())
                     {
                         try
                         {
                             while (key < dic.Count)
                             {
                                 Console.WriteLine($"读线程3：{dic[key++]}");
                             }
                         }
                         catch (Exception ex)
                         {
                             ;
                         }
                         finally
                         {
                             lockSlim.ExitReadLock();
                         }
                     }
                 }
             });
             Task.Factory.StartNew(() =>
             {
                 while (true)
                 {
                     Thread.Sleep();
                     int key = ;
                     if (lockSlim.TryEnterReadLock())
                     {
                         try
                         {
                             while (key < dic.Count)
                             {
                                 Console.WriteLine($"读线程4：{dic[key++]}");
                             }
                         }
                         catch (Exception ex)
                         {
                             ;
                         }
                         finally
                         {
                             lockSlim.ExitReadLock();
                         }
                     }
                 }
             });
             Console.ReadKey();
         }

.NET 同步与异步之锁（ReaderWriterLockSlim）（八）

c#线程同步系列（二） c#中ReaderWriterLock的使用

读写锁ReaderWriterLockSlim