读写锁的概念很简单,允许多个线程同时获取读锁,但同一时间只允许一个线程获得写锁,因此也称作共享-独占锁。
某些场合下,对一个对象的读取次数远远大于修改次数,如果只是简单的用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
http://files.cnblogs.com/files/xchit/Thread_example.rar