C#多线程同步 读写锁ReaderWriterLock的用法

同一个线程同时只能持有ReaderWriterLock读写锁中的读锁或者写线二者之一，不能同时都持有。ReaderWriterLock读写锁适用于读多写少且写持续时间短的场景，更适用多个线程读单个线程写，以便于读线程和写线程都不被阻止很长一段时间，这样的执行效率就提高了。

这里先通过案例代码了解ReaderWriterLock读写锁中的读锁是如何应用的：

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

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks;   namespace What21Thread {     class Program     {         static void Main(string[] args)         {             // 创建读写锁             ReaderWriterLock rwLock = new ReaderWriterLock();               // 当前线程获取读锁，参数为：超时值（毫秒）             rwLock.AcquireReaderLock(250);             // 判断当前线程是否持有读锁             if (!rwLock.IsReaderLockHeld)             {                 return;             }             Console.WriteLine("拿到了读锁......");               // 将读锁升级为写锁，锁参数为：超时值（毫秒）             LockCookie cookie = rwLock.UpgradeToWriterLock(250);             // 判断当前线程是否持有写锁             if (rwLock.IsWriterLockHeld)             {                 Console.WriteLine("升级到了写锁......");                 // 将锁还原到之前所的级别，也就是读锁                 rwLock.DowngradeFromWriterLock(ref cookie);             }             // 释放读锁（减少锁计数，直到计数达到零时，锁被释放）             rwLock.ReleaseReaderLock();               Console.WriteLine("顺利执行完毕......");             Console.ReadLine();         }     } }

1、创建读写锁对象：ReaderWriterLock rwLock = new ReaderWriterLock();

2、线程通过方法：AcquireReaderLock("毫秒")获取到读锁，线程多次调用次方法，每次回增加锁的计数；调用了该方法后，必须调用ReleaseReaderLock()方法释放锁。

3、通过IsReaderLockHeld属性，用来判断当前线程是否持有读锁。

4、通过UpgradeToWriterLock("毫秒")方法，可以将读锁升级为写锁。

5、通过IsWriterLockHeld属性，用来判断当前线程是否持有写锁。

6、通过DowngradeFromWriterLock("LockCookie")方法，将锁还原到之前锁的级别。

7、最后使用ReleaseReaderLock()来释放掉读锁，读写锁会减少锁计数，当计数达到零时，锁就会被释放；线程如果没有读锁会抛出异常ApplicationException。

再通过案例代码了解ReaderWriterLock读写锁中的写锁是如何应用的：

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

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks;   namespace What21Thread {     class Program     {         static void Main(string[] args)         {              // 创建读写锁             ReaderWriterLock rwLock = new ReaderWriterLock();             // 当前线程获取写锁，参数为：超时值（毫秒）             rwLock.AcquireWriterLock(250);             // 判断当前线程是否持有写锁             if (rwLock.IsWriterLockHeld)             {                 Console.WriteLine("拿到了写锁......");                 // 释放写锁（将减少写锁计数，直到计数变为零，释放锁）                 rwLock.ReleaseWriterLock();             }             // 释放写锁（将减少写锁计数，直到计数变为零，释放锁）             // 当前线程不持有锁，会抛出异常             rwLock.ReleaseWriterLock();               Console.WriteLine("顺利执行完毕......");             Console.ReadLine();         }     } }

1、线程通过AcquireWriterLock("毫秒")方法来获取到写锁，超过"毫秒"数获取不到锁，抛出ApplicationException异常。

2、通过ReleaseWriterLock()方法释放掉写锁，如果线程没有锁会抛出ApplicationException异常。

这里通过读写锁完成一个复杂的业务：

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

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks;   namespace What21Thread {     public class Account     {         // 参数         public string company = "what21";         public decimal balance = 0.0m;         // 最后更新时间         public DateTime lastUpdate = DateTime.Now;         // 读写锁         public ReaderWriterLock syncLock = new ReaderWriterLock();           // 更新delta参数         internal decimal AutoUpdateBalance(decimal delta)         {             // 获取写锁             syncLock.AcquireWriterLock(-1);             try             {                 balance += delta;                 lastUpdate = DateTime.Now;                 Console.WriteLine("{0}, 账目: {1}, 操作时间: {2}", company, balance, lastUpdate);                 return balance;             }             finally             {                 // 释放写锁                 syncLock.ReleaseWriterLock();             }         }           // 获取状态         public void GetState(out string company, out decimal balance, out DateTime lastUpdate)         {             // 获取读锁             syncLock.AcquireReaderLock(-1);             try             {                 company = this.company;                 balance = this.balance;                 lastUpdate = this.lastUpdate;             }             finally             {                 // 释放读锁                 syncLock.ReleaseReaderLock();             }         }                } }

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

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks;   namespace What21Thread {     class Program     {         static void Main(string[] args)         {             // 创建account对象             Account account = new Account();             // 定义参数             string company;             decimal balance;             DateTime lastUpdate;             for (int i = 0; i < 2; i++)             {                 Thread thread = new Thread(WorkerOperation);                 thread.Start(account);             }                          account.GetState(out company, out balance, out lastUpdate);             Console.WriteLine("{0}, 账目: {1}, 最后操作时间: {2}", company, balance, lastUpdate);               Console.ReadLine();         }           // 定义线程方法         private static void WorkerOperation(object o)         {             Account account = (Account)o;             Random ran = new Random();             int RandKey = ran.Next(100, 999);             account.AutoUpdateBalance(RandKey);         }     } }

方法AcquireReaderLock(-1)：这里-1参数是直到拿到读锁为止。

方法AcquireWriterLock(-1)：这里-1参数是直到拿到写锁为止。

这个业务是模拟公司的账户，一个公司账户有支出有收入，就相当于读、写线程在交替操作，最主要的是这里使用ReaderWriterLock读写锁，让我们能够更好的学习它，熟悉它。