[.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 = 0;
                while (key <= 1000)
                {
                    Thread.Sleep(10);
                    string info = $"写线程：{DateTime.Now.ToString("hhMMss-fff")}";
                    if (lockSlim.TryEnterWriteLock(20))
                    {
                        try
                        {
                            dic.Add(key++, info);
                            Console.WriteLine(info);
                        }
                        catch (Exception ex)
                        {
                            ;
                        }
                        finally
                        {
                            Console.WriteLine($"释放 {info}");
                            lockSlim.ExitWriteLock();
                        }
                    }
                }
            });
            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    Thread.Sleep(100);
                    int key = 0;
                    if (lockSlim.TryEnterReadLock(20))
                    {
                        try
                        {
                            while (key < dic.Count)
                            {
                                Console.WriteLine($"读线程1：{dic[key++]}");
                            }
                        }
                        catch (Exception ex)
                        {
                            ;
                        }
                        finally
                        {
                            lockSlim.ExitReadLock();
                        }
                    }
                }
            });
            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    Thread.Sleep(100);
                    int key = 0;
                    if (lockSlim.TryEnterReadLock(20))
                    {
                        try
                        {
                            while (key < dic.Count)
                            {
                                Console.WriteLine($"读线程2：{dic[key++]}");
                            }
                        }
                        catch (Exception ex)
                        {
                            ;
                        }
                        finally
                        {
                            lockSlim.ExitReadLock();
                        }
                    }
                }
            });
            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    Thread.Sleep(100);
                    int key = 0;
                    if (lockSlim.TryEnterReadLock(20))
                    {
                        try
                        {
                            while (key < dic.Count)
                            {
                                Console.WriteLine($"读线程3：{dic[key++]}");
                            }
                        }
                        catch (Exception ex)
                        {
                            ;
                        }
                        finally
                        {
                            lockSlim.ExitReadLock();
                        }
                    }
                }
            });
            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    Thread.Sleep(100);
                    int key = 0;
                    if (lockSlim.TryEnterReadLock(20))
                    {
                        try
                        {
                            while (key < dic.Count)
                            {
                                Console.WriteLine($"读线程4：{dic[key++]}");
                            }
                        }
                        catch (Exception ex)
                        {
                            ;
                        }
                        finally
                        {
                            lockSlim.ExitReadLock();
                        }
                    }
                }
            });
            Console.ReadKey();
        }

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

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

读写锁ReaderWriterLockSlim