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

是的，您的描述听起来不错。在中传递锁定对象可能有点不寻常，但它会正常工作。我建议的唯一更改是制作static字段readonly，这样您就不会意外地将值更改为其他object引用。

Answer 2

是的，这是正确的。 A中的锁和B中的锁完全没有意识到彼此。只有当另一个线程使用与标识符相同的对象锁定代码时，才会阻止代码。

Answer 3

您的结论是正确的，但传递锁定对象不是一个好习惯。我建议将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 4

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

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

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

}

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

c＃中的锁码部分

4 个答案: