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

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

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

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读写锁中的写锁是如何应用的：

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异常。

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

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

    }
}

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读写锁，让我们能够更好的学习它，熟悉它。