C#多线程系列之读写锁

C# 多线程系列之读写锁

什么是读写锁？

读写锁允许同时有多个线程来读取共享资源，但一次只允许一个线程来写入共享资源。这可能会带来一些好处，比如更快的数据访问速度。

读写锁的基本思想是：

• 如果它是一个读访问，它可以并发进行。
• 如果它是一个写入访问，则它需要独占式地进行。

读写锁的实现方式

ReaderWriterLock

在 .NET Framework 3.5 及更早期版本中，可以使用 ReaderWriterLock 类实现读写锁。例如，以下代码演示了如何在两个读线程和一个写线程之间进行读写访问。

class Locker
{
    private ReaderWriterLock rwLock = new ReaderWriterLock();

    public void ReadMessage()
    {
        rwLock.AcquireReaderLock(Timeout.Infinite);
        try
        {
            Console.WriteLine("Received message");
        }
        finally
        {
            rwLock.ReleaseReaderLock();
        }
    }

    public void WriteMessage()
    {
        rwLock.AcquireWriterLock(Timeout.Infinite);
        try
        {
            Console.WriteLine("Wrote message");
        }
        finally
        {
            rwLock.ReleaseWriterLock();
        }
    }
}

ReaderWriterLockSlim

在 .NET Framework 4 及更高版本中，可以使用 ReaderWriterLockSlim 类实现读写锁。ReaderWriterLockSlim 具有和 ReaderWriterLock 类似的语义，但它更加灵活和高效。

class Locker
{
    private ReaderWriterLockSlim rwLockSlim = new ReaderWriterLockSlim();

    public void ReadMessage()
    {
        rwLockSlim.EnterReadLock();
        try
        {
            Console.WriteLine("Received message");
        }
        finally
        {
            rwLockSlim.ExitReadLock();
        }
    }

    public void WriteMessage()
    {
        rwLockSlim.EnterWriteLock();
        try
        {
            Console.WriteLine("Wrote message");
        }
        finally
        {
            rwLockSlim.ExitWriteLock();
        }
    }
}

ReaderWriterLockSlim 支持可升级和可降级锁，这些锁可以在不同级别之间自由切换，从而提高了性能。

使用读写锁的注意事项

应该仅在必要的情况下使用读写锁，以避免过度同步或死锁。同时，需要仔细考虑在数据访问时是否需要使用读写锁。例如，如果数据访问很少，一个简单的锁就足够了。

为了使读写锁发挥最佳性能，应该避免死锁或饥饿状态。死锁可能发生在多个线程同时等待对锁的访问权限时，而饥饿状态则可能发生在某些线程一直在等待访问权限，而其他线程则不停地访问共享资源。

以下是一个使用 ReaderWriterLockSlim 的示例：

class Program
{
    static Locker locker = new Locker();
    static void Main(string[] args)
    {
        Thread writerThread = new Thread(WriteMessages);
        Thread readerThread1 = new Thread(ReadMessages);
        Thread readerThread2 = new Thread(ReadMessages);

        writerThread.Start();
        readerThread1.Start();
        readerThread2.Start();

        writerThread.Join();
        readerThread1.Join();
        readerThread2.Join();
    }

    static void WriteMessages()
    {
        for (int i = 0; i < 5; i++)
        {
            locker.WriteMessage();
            Thread.Sleep(500);
        }
    }

    static void ReadMessages()
    {
        for (int i = 0; i < 5; i++)
        {
            locker.ReadMessage();
            Thread.Sleep(500);
        }
    }
}

在上面的示例中，有线程写入消息，同时有两个线程读取消息，它们都在等待锁的权限。当一个线程拥有写入权限时，其他线程都需要等待，但当一个线程拥有读取权限时，其他读取线程也可以同时访问共享资源。

需要注意的是，如果读取操作并不频繁，可以考虑使用 Monitor 类来替代 ReaderWriterLock、ReaderWriterLockSlim 等锁。