如何使用C#读写锁ReaderWriterLockSlim

下面是详细讲解如何使用C#读写锁ReaderWriterLockSlim的攻略：

什么是ReaderWriterLockSlim？

ReaderWriterLockSlim是一个线程同步机制，用于实现在多个线程之间共享对某个资源的读取和写入。它可以提供高性能的读取操作和相对低性能的写操作。

使用ReaderWriterLockSlim可以控制多个线程同时读取一个共享资源，而只允许一个线程写入。在读写锁的资源上读和写会产生互斥。在任何给定的时间内，只能有一个线程能够持有写锁，但可以有任意多个线程持有读锁。向同一个ReaderWriterLockSlim对象请求读写锁可以是递归的。

如何使用ReaderWriterLockSlim？

首先，需要在代码中创建一个ReaderWriterLockSlim对象，如下所示：

ReaderWriterLockSlim rwl = new ReaderWriterLockSlim();

然后就可以使用锁的方法来控制对共享资源的访问了。常用的有：

EnterReadLock / ExitReadLock

调用EnterReadLock方法使当前线程获取读锁，调用ExitReadLock方法释放读锁。在读锁被持有的时候，其他线程也可以获取读锁，但是不能获得写锁。

rwl.EnterReadLock();

try
{
    // Do something with the shared resource.
}
finally
{
    rwl.ExitReadLock();
}

EnterWriteLock / ExitWriteLock

调用EnterWriteLock方法使当前线程获取写锁，调用ExitWriteLock方法释放写锁。在写锁被持有的时候，其他线程不能获取读写锁。

rwl.EnterWriteLock();

try
{
    // Do something with the shared resource.
}
finally
{
    rwl.ExitWriteLock();
}

TryEnterReadLock / TryEnterWriteLock / TryEnterUpgradeableReadLock

这些方法可以在没有锁被持有的情况下试图获取一个锁。TryEnterReadLock方法将会在当前没有写锁时获取读锁，而TryEnterWriteLock方法只有在当前没有读锁或写锁时才会获取写锁。TryEnterUpgradeableReadLock方法在当前没有写锁时获取读锁，但允许随后升级到写锁。

if (rwl.TryEnterReadLock(1000))
{
    try
    {
        // Do something with the shared resource.
    }
    finally
    {
        rwl.ExitReadLock();
    }
}
else
{
    // Can't get the lock in 1000 ms. 
}

示例

示例1

在下面的示例中，我们创建了一个List来模拟共享资源。两个线程分别获取读锁和写锁，然后读线程读取列表的内容并输出，在读取完成后写线程向列表中添加一个元素。注意，写锁需要等待读线程结束后才能持有。

using System;
using System.Threading;

class MyProgram
{
    static ReaderWriterLockSlim rwl = new ReaderWriterLockSlim();
    static Random random = new Random();

    static void Main()
    {
        // Create a new List<int> to simulate a shared resource.
        System.Collections.Generic.List<int> list = new System.Collections.Generic.List<int>();

        // Start a read thread.
        new Thread(() =>
        {
            while (true)
            {
                // Enter a read-lock to access the shared resource.
                rwl.EnterReadLock();

                try
                {
                    // Read from the shared resource.
                    foreach (int value in list)
                    {
                        Console.Write(value + " ");
                    }
                    Console.WriteLine();
                }
                finally
                {
                    // Release the lock.
                    rwl.ExitReadLock();
                }

                // Wait for a while before reading again.
                Thread.Sleep(random.Next(50, 150));
            }
        }).Start();

        // Start a write thread.
        new Thread(() =>
        {
            while (true)
            {
                // Enter a write-lock to access the shared resource.
                rwl.EnterWriteLock();

                try
                {
                    // Write to the shared resource.
                    list.Add(random.Next(1, 10));
                }
                finally
                {
                    // Release the lock.
                    rwl.ExitWriteLock();
                }

                // Wait for a while before writing again.
                Thread.Sleep(random.Next(200, 600));
            }
        }).Start();

        // Keep the main thread from ending.
        Thread.Sleep(Timeout.Infinite);
    }
}

示例2

下面是一个使用ReaderWriterLockSlim协调读写的示例，来自MSDN：

class MyData
{
    private List<int> list = new List<int>();
    private ReaderWriterLockSlim rwl = new ReaderWriterLockSlim();

    public void Add(int item)
    {
        rwl.EnterWriteLock();
        try
        {
            list.Add(item);
        }
        finally
        {
            rwl.ExitWriteLock();
        }
    }

    public void RemoveAt(int index)
    {
        rwl.EnterWriteLock();
        try
        {
            list.RemoveAt(index);
        }
        finally
        {
            rwl.ExitWriteLock();
        }
    }

    public int this[int index]
    {
        get
        {
            rwl.EnterReadLock();
            try
            {
                return list[index];
            }
            finally
            {
                rwl.ExitReadLock();
            }
        }
        set
        {
            rwl.EnterWriteLock();
            try
            {
                list[index] = value;
            }
            finally
            {
                rwl.ExitWriteLock();
            }
        }
    }

    public int Count
    {
        get
        {
            rwl.EnterReadLock();
            try
            {
                return list.Count;
            }
            finally
            {
                rwl.ExitReadLock();
            }
        }
    }
}