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

posted @ 2020-07-10 17:26 奋斗的中年人哈哈哈阅读(1261) 评论(0) 编辑收藏举报

刷新页面返回顶部

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

公告

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