Question

我正在尝试使用ReaderWriterLockSlim类来管理列表。

这个列表有很多读取，写入很少，我的读取很快，而我的写入很慢。

我编写了一个简单的测试工具来检查锁的工作原理。

如果出现以下情况

Thread 1 - Start Write
Thread 2 - Start Read
Thread 3 - Start Write

然后结果如下

Thread 1 starts its write and locks the list.
Thread 2 adds itself to the read queue.
Thread 3 adds itself to the write queue.
Thread 1 finishes writing and releases the lock
Thread 3 aquires the lock and starts its write
Thread 3 finishes writing and releases the lock
Thread 2 performs its read

是否有任何方法可以更改锁的行为，以便在授予写锁之前允许在写锁之前排队的任何读取请求完成？

编辑：演示我遇到的问题的代码如下

public partial class SimpleLock : System.Web.UI.Page
{
    public static ReaderWriterLockSlim threadLock = new ReaderWriterLockSlim();

    protected void Page_Load(object sender, EventArgs e)
    {
        List<String> outputList = new List<String>();

        Thread thread1 = new Thread(
            delegate(object output)
            {
                ((List<String>)output).Add("Write 1 Enter");
                threadLock.EnterWriteLock();
                ((List<String>)output).Add("Write 1 Begin");
                Thread.Sleep(100);
                ((List<String>)output).Add("Write 1 End");
                threadLock.ExitWriteLock();
                ((List<String>)output).Add("Write 1 Exit");
            }
        );
        thread1.Start(outputList);

        Thread.Sleep(10);

        Thread thread2 = new Thread(
            delegate(object output)
            {
                ((List<String>)output).Add("Read 2 Enter");
                threadLock.EnterReadLock();
                ((List<String>)output).Add("Read 2 Begin");
                Thread.Sleep(100);
                ((List<String>)output).Add("Read 2 End");
                threadLock.ExitReadLock();
                ((List<String>)output).Add("Read 2 Exit");
            }
        );
        thread2.Start(outputList);

        Thread.Sleep(10);

        Thread thread3 = new Thread(
            delegate(object output)
            {
                ((List<String>)output).Add("Write 3 Enter");
                threadLock.EnterWriteLock();
                ((List<String>)output).Add("Write 3 Begin");
                Thread.Sleep(100);
                ((List<String>)output).Add("Write 3 End");
                threadLock.ExitWriteLock();
                ((List<String>)output).Add("Write 3 Exit");
            }
        );
        thread3.Start(outputList);

        thread1.Join();
        thread2.Join();
        thread3.Join();

        Response.Write(String.Join("<br />", outputList.ToArray()));
    }
}

Answer 1

有没有办法改变锁的行为，以便任何在允许写入锁之前读取已排队的请求在授予写锁之前完成？

几乎完全避免使用锁怎么样？在写入期间，您可以获取锁定，复制原始数据结构，修改副本，然后通过使用新引用交换旧引用来发布新数据结构。由于您从未在“已发布”后修改数据结构，因此您根本不需要锁定读取。

以下是它的工作原理：

public class Example
{
  private object writelock = new object();
  private volatile List<string> data = new List<string>();

  public void Write(string item)
  {
    lock (writelock)
    {
      var copy = new List<string>(data); // Create the copy.
      copy.Add(item); // Modify the data structure.
      data = copy; // Publish the modified data structure.
    }
  }

  public string Read(int index)
  {
    return data[index];
  }
}

我们在这里利用的技巧是data变量引用的不变性。我们唯一需要做的就是将变量标记为volatile。

请注意，只有在写入足够频繁并且数据结构足够小以保持复制操作便宜时，此技巧才有效。它不是全部解决方案。它并不适用于所有场景，但它可能对您有用。

ReaderWriterLockSlim阻塞读取，直到所有排队写入完成

1 个答案: