C#中lock与‘readonly lock’：多线程读写同步方案问询

场景说明 #

我的应用中有多个线程（例如20个读线程）从集合读取数据，另有一个线程负责定期刷新该集合的数据。

使用普通lock的缺陷 #

使用标准lock语句时，所有读线程和写线程都会互相阻塞，同一时间仅能有一个读线程访问数据，示例代码如下：

private readonly object lockObj = new Object();
private List<string> data;

public void dataReader1(){
   lock(lockObj){
      // 读取操作...
   }
}

public void dataReader2(){
   lock(lockObj){
      // 读取操作...
   }
}

public void dataReader3(){
   lock(lockObj){
      // 读取操作...
   }
}

public void dataWriter(){
   lock(lockObj){
      // 写入操作...
   }
}

尝试的多锁方案（存在死锁风险） #

为解决读线程互斥的问题，我尝试使用一个全局写锁和多个独立读锁：读线程可同时读取，写线程需先锁定所有读锁，再获取独占写锁。示例代码如下：

private List<string> data;

private readonly object writeLock = new Object();
private readonly object readLock1 = new Object();
private readonly object readLock2 = new Object();
private readonly object readLock3 = new Object();

public void dataReader1(){
   lock(readLock1){
      // 读取操作...
   }
}

public void dataReader2(){
   lock(readLock2){
      // 读取操作...
   }
}

public void dataReader3(){
   lock(readLock3){
      // 读取操作...
   }
}

public void dataWriter(){
   lock(readLock1){
      lock(readLock2){
         lock(readLock3){
             lock(writeLock){
                // 写入操作...
             }
          }
      }
   }
}

但这种嵌套锁的方式容易引发死锁，我并不满意该方案。

期望的原生实现逻辑 #

我希望C#能提供原生支持，通过单个锁对象实现多读单写的逻辑：

• 多个读线程可同时进入readonly lock，仅当存在写锁（或正在尝试获取写锁）时才会阻塞
• 写线程的普通lock需等待所有读锁释放后才能获取

设想的语法示例如下：

private readonly object lockObj= new Object();
private List<string> data;

public void dataReader1(){
   readonly lock(lockObj){
      // 读取操作...
   }
}

public void dataReader2(){
   readonly lock(lockObj){
      // 读取操作...
   }
}

public void dataReader3(){
   readonly lock(lockObj){
      // 读取操作...
   }
}

public void dataWriter(){
   lock(lockObj){
      // 写入操作...
   }
}

请问C#是否有原生方式实现这种逻辑？

内容的提问来源于stack exchange，提问作者dognose