读写锁ReaderWriterLockSlim

　　读写锁的概念很简单，允许多个线程同时获取读锁，但同一时间只允许一个线程获得写锁，因此也称作共享-独占锁。

　　某些场合下，对一个对象的读取次数远远大于修改次数，如果只是简单的用lock方式加锁，则会影响读取的效率。而如果采用读写锁，则多个线程可以同时读取该对象，只有等到对象被写入锁占用的时候，才会阻塞。

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

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

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

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

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

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

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

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

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

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

　　下面演示一下用法：

　　

            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());
            }
        }

在12号线程开启写入模式时候，10号线程和11号线程的读取模式还在运行中，过了5秒后，读取模式结束了，12号线程才开始写入模式；

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

            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());

可以看到9号线程和10号线程同时开启写入模式，但9号线程先开始，必须等到9号线程结束后，10号线程才能开始写入模式，而读取模式必须要10号线程结束后，11和12号线程可以同时进行读取模式；

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

　　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());
            }
        }

 

  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();
            }
        } 

测试代码：

            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);
            

上述代码，就500个Task，每个Task占用一个线程池线程，其中20个写入线程和480个读取线程，模拟操作。其中读取数据花10ms，写入操作花100ms，分别测试了对于lock方式和ReaderWriterLockSlim方式。可以做一个估算，对于ReaderWriterLockSlim，假设480个线程同时读取，那么消耗10ms，20个写入操作占用2000ms，因此所消耗时间2010ms，而对于普通的lock方式，由于都是独占性的，因此480个读取操作占时间4800ms+20个写入操作2000ms=6800ms。运行结果显示了性能提升明显。

还有ReaderWriterLockSlim的封装：

http://www.cnblogs.com/blqw/p/3475734.html

实例demo 

https://files.cnblogs.com/files/xchit/Thread_example.rar