c#中的锁定代码部分

Question

我的问题可能听起来像这里的许多其他问题，但它有一种我没有找到的味道。

我试图理解以下逻辑

一个通用对象

public class GenericClass
{
    public static void DoSomething(Object lockObj)
    {
        lock(lockObj)
        {
            // do something here
        }
    }
} 

A类

internal class A
{
    private static _aLock = new Object();

    public void Do_A_Thing()
    {
        GenericClass.DoSomething(_aLock);
    }
} 

B类

internal class B
{
    private static _bLock = new Object();

    public void Do_B_Thing()
    {
        GenericClass.DoSomething(_bLock);
    }
} 

我只是希望确认我的解释是否正确：

如果“A”类的多个线程将尝试同时访问“genericClass”方法“DoSomething”中的代码，则该方法将被锁定到除一个“A”类实例之外的所有实例。但是“B”类的单个实例将能够随时继续执行。如果“B”类也将执行多个实例，则它们不会干扰“A”类锁。

根据您在上面看到的情况，这是正确的吗？

Answer 1

是的，您的描述听起来很正确。传递锁对象in 可能有点不寻常，但它会正常工作。我建议的唯一更改是将static 字段设置为readonly，这样您就不会意外地将值更改为不同的object 引用。

Answer 2

您的结论是正确的，但传递锁定的对象并不是一个好习惯。我建议将lock 分别放在 A 类和 B 类中。

我建议写：

internal class A
{
    private static readonly _aLock = new Object();

    public void Do_A_Thing()
    {
        lock (_aLock)
        {
            GenericClass.DoSomething();
        }
    }
} 

您是否有特定的理由将锁放在另一个类中？也许你可以用不同的方式解决你的问题？

另外请记住，在某些情况下，可能不是您的情况，如果 A 类和 B 类相互调用（A->B->A），您可能会出现死锁。

Answer 3

是的，没错。 A 中的锁和B 中的锁完全不知道彼此。只有当有另一个线程使用与标识符相同的对象锁定它时，代码才会被阻塞。

Answer 4

如果您使用的是泛型，那么类似

public class MyGadget<T>
{
  static readonly SyncRoot = new object() ;

  public T SynchronizedMethod()
  {
     lock ( SyncRoot )
     {
        SynchronizedMethodGuts() ;
     }
  }

}

应该做你想做的，因为MyGadget<Foo> 和MyGadget<Bar> 是不同的类：它们都有自己的、不同的SyncRoot 字段。