C# | 对比不同种类的锁

C# 对比不同种类的锁

Hi，在C#编程中，想要保护共享资源，通常会用到各种类型的锁。今天我们就来一起看看C#中不同种类的锁，包括它们的异同点和使用方法。

异同点对比表

先让我们来看看各种锁的异同点：

锁类型	特点	使用场景
lock语句	简单易用，在单个方法内部有效。	简单的局部锁定需求
Monitor类	可实现更复杂的锁定功能，具有更灵活的等待和通知机制。	复杂的同步控制需求
Mutex类	可以跨进程使用，适合在跨进程共享资源的情况下进行锁定。	跨进程共享资源的锁定需求
Semaphore类	允许多个线程同时访问共享资源，适合对资源的并发访问进行控制。	并发访问资源控制需求
ReaderWriterLock类	可以对读写操作进行分离，提高并发读的性能。	读写分离且对读并发性能要求较高的场景

使用方法

lock语句

class Program
{
    private object _lock = new object(); // 创建一个对象作为锁

    public void DoSomething()
    {
        lock (_lock) // 使用lock语句锁定代码块
        {
            // 实现需要保护的代码
        }
    }
}

使用场景： 当需要在单个方法内简单地保护一段代码时使用。

Monitor类

class Program
{
    private static object _lock = new object(); // 创建共享锁对象

    public void DoSomething()
    {
        Monitor.Enter(_lock); // 获取锁
        try
        {
            // 实现需要保护的代码
        }
        finally
        {
            Monitor.Exit(_lock); // 释放锁
        }
    }
}

使用场景： 在需要更复杂的同步控制以及在等待和通知机制时使用。

Mutex类

class Program
{
    private static Mutex _mutex = new Mutex(); // 创建互斥锁

    public void DoSomething()
    {
        _mutex.WaitOne(); // 等待获取锁
        try
        {
            // 实现需要保护的代码
        }
        finally
        {
            _mutex.ReleaseMutex(); // 释放锁
        }
    }
}

使用场景： 在跨进程共享资源的情况下进行锁定时使用。

Semaphore类

class Program
{
    private static Semaphore _semaphore = new Semaphore(2, 2); // 创建信号量

    public void DoSomething()
    {
        _semaphore.WaitOne(); // 等待获取信号量
        try
        {
            // 实现需要保护的代码
        }
        finally
        {
            _semaphore.Release(); // 释放信号量
        }
    }
}

使用场景： 在需要对资源的并发访问进行控制时使用，允许多个线程同时访问共享资源。

ReaderWriterLock类

class Program
{
    private static ReaderWriterLock _rwLock = new ReaderWriterLock(); // 创建读写锁

    public void ReadSomething()
    {
        _rwLock.AcquireReaderLock(); // 获取读锁
        try
        {
            // 读取操作
        }
        finally
        {
            _rwLock.ReleaseReaderLock(); // 释放读锁
        }
    }

    public void WriteSomething()
    {
        _rwLock.AcquireWriterLock(); // 获取写锁
        try
        {
            // 写入操作
        }
        finally
        {
            _rwLock.ReleaseWriterLock(); // 释放写锁
        }
    }
}

使用场景： 在需要对读写操作进行分离，并且对读并发性能有较高要求时使用。

结语

希望以上的介绍可以帮助你更好的选择和使用不同种类的锁来保护你的共享资源。记得在多线程编程中选择恰当的锁是很重要的哦！