C# 主/从锁定系统的类型？

我不知道我想做的事情有没有名字。 遗憾的是，“主/从锁定系统”是我能想到的最好的措辞

现在来谈谈我的问题

假设您有以下类：

public class Foo
{
    public void Master()
    {

    }

    public void Slave1()
    {

    }

    public void Slave2()
    {

    }
}

我希望从属方法（Slave1、Slave2）可以在多线程场景中并行运行，但是当主（主）方法被调用时，从属方法将在执行时被阻止执行，其他所有当前运行的从属方法将在进入主方法时运行到完成

类似这样的内容（附注释）：

我知道我可以在所有3种方法上使用lock，但是Slave1方法会相互阻塞，这不是我想要的

public class Foo
{
    private readonly object _syncLock = new object();

    public void Master()
    {
        lock (_syncLock) //blocks Slave1, Slave2
        {
            //run code...
        }
    }

    public void Slave1()
    {
        lock (_syncLock) //blocks Slave2, Master - dont want that
        {
            //run code...
        }
    }

    public void Slave2()
    {
        lock (_syncLock) //blocks Slave1, Master - dont want that
        {
            //run code...
        }
    }
}

---

如果可能的话，我希望解决方案在这个类内部，而不是外部“如果你这样调用方法，它就会这样做”，提到的方法可以在任何时候以非顺序的方式启动，每个方法可以运行多次。

如果我理解正确，你想

• Master（）

  上的独占（写）锁（没有

  SlaveN

  可以运行）
• 每个

  从机上的共享（读取）锁

  （您可以运行另一个

  SlaveN

  ，但不能运行

  Master

  ）

如果是您的情况，请查看：

---

您正在寻找的是一个多读写器单写器锁。请查看一下

ReaderWriterLockSlim

（主线程==写入，从线程==读取；多线程用于读取或独占访问用于写入）在

锁中只需使用两个对象即可。JeremyCompson您可以与两个对象共享一些代码吗？对于给定的问题，我不认为这是可能的。+1表示理解。：）为了澄清我是否有两个主方法，我可以调用_syncLock.EnterWriteLock（）；两次并按预期进行阻塞，或者它会抛出异常？EnterWriteLock会等到所有方法都调用ExitReadLock吗？这不是另一种方式吗？因为在释放所有读锁之前，master将被阻止执行？@poke这正是我所希望的，如果调用master（）方法，它应该等到所有已经运行的从属方法完成，并阻止任何额外的从属方法直到自己完成。
\u syncLock.EnterWriteLock（）
意味着为我提供独占权限，因此，
Master
s中的一个必须等待；您不想等待，可能需要使用
TryEnterReadLock
/
TryEnterReadLock
命令。
public class Foo
{
    private readonly object _syncLock = new object();

    public void Master()
    {
        lock (_syncLock) //blocks Slave1, Slave2
        {
            //run code...
        }
    }

    public void Slave1()
    {
        lock (_syncLock) //blocks Slave2, Master - dont want that
        {
            //run code...
        }
    }

    public void Slave2()
    {
        lock (_syncLock) //blocks Slave1, Master - dont want that
        {
            //run code...
        }
    }
}

public class Foo {
    private readonly ReaderWriterLockSlim _syncLock = new ReaderWriterLockSlim();

    public void Master() {
      // Exclusive (write) lock: only Master allowed to run
      _syncLock.EnterWriteLock();

      try {
        //run code...
      }
      finally {
        _syncLock.ExitWriteLock();
      }   
    }

    public void Slave1() {
      // Read lock: you can run Slave2 (with another Read lock), but not Master 
      _syncLock.EnterReadLock();

      try {
        //run code...
      }
      finally {
        _syncLock.ExitReadLock();
      }         
    }

    public void Slave2() {
      // Read lock: you can run Slave1 (with another Read lock), but not Master 
      _syncLock.EnterReadLock();

      try {
        //run code...
      }
      finally {
        _syncLock.ExitReadLock();
      }         
    }   
}