c# - 一种主/从锁定系统？

Question

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

现在我遇到的问题...

假设您有以下类(class):

public class Foo
{
    public void Master()
    {

    }

    public void Slave1()
    {

    }

    public void Slave2()
    {

    }
}

我希望的是在多线程场景下，slaves方法(Slave1，Slave2)可以并行运行，但是当master(Master)方法被调用时，slaves方法在执行的过程中应该被阻塞执行，另外所有当前正在运行的从属方法在进入主方法时应运行完成。

像这样的东西(带评论):

public class Foo
{
    public void Master()
    {
        //block slaves from executing
        //wait for slaves to finish

        //do code...

        //unblock slaves
    }

    public void Slave1()
    {
        //if blocked by master wait, if not execute
        //if currently running when entering master method, let it finish
    }

    public void Slave2()
    {
        //if blocked by master wait, if not execute
        //if currently running when entering master method, let it finish
    }
}

我知道我可以在所有 3 个方法上使用锁，但是 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...
        }
    }
}

如果可能的话，我希望将解决方案放在此类内部而不是外部“如果您以这种方式调用方法，它就会这样做”，所提到的方法可以在任何时候以无序的方式触发，并且每个方法都可以运行多次。

Answer 1

如果我没理解错的话，你想把

• Master() 独占(写)锁(SlaveN 无法运行)
• 在每个 Slave 上共享(读取)锁(您可以运行另一个 SlaveN，但不能运行 Master)

如果是您的情况，请查看 ReaderWriterLockSlim :

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();
      }         
    }   
}