2

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

我试图理解以下逻辑

通用对象

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”类锁。

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

4

4 回答 4

3

是的，你的描述听起来是正确的。将锁定对象传入 可能有点不寻常，但它会正常工作。我建议的唯一更改是创建static字段readonly，这样您就不会意外地将值更改为不同的object参考。

于 2013-09-24T22:13:38.083 回答
2

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

我建议写：

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

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

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

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

于 2013-09-24T22:31:25.340 回答
2

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

于 2013-09-24T22:15:20.423 回答
0

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

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

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

}

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

于 2013-09-25T00:22:26.307 回答