C# c语言中的锁代码部分#

我的问题听起来可能和这里的许多其他问题一样，但它有一种我没有发现的味道

我试图理解以下逻辑

泛型对象

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

甲级

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

---

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

是的，您的描述听起来正确。传递lock对象可能有点不寻常，但它可以正常工作。我建议的唯一更改是将

字段设置为static

readonly，这样您就不会意外地将值更改为不同的

对象

引用。

是的，这是正确的。

A

中的锁和

B

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

您的结论是正确的，但传递锁定的对象不是一个好的做法。我建议把

锁

分别放在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），您可能会出现死锁。

如果您使用泛型，则类似

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

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

}

公共类MyGadget
{
静态只读SyncRoot=新对象（）；
公共T同步方法（）
{
锁定（同步根）
{
SynchronizedMethodGuts（）；
}
}
}

---

应该做你想做的事情，因为

MyGadget

和

MyGadget

是不同的类：

SyncRoot

字段各不相同。

是。。。虽然结构看起来有点吓人，但你真的有

lock（lockObj）末尾的code>？你不应该。这就像拥有
if（someCondition）；{//do stuff}
：您仅将
锁
或
if
应用于由
指示的空语句
，而不是
{}
指示的代码块。通常，您希望锁定对象是私有的，这样您就知道没有其他人可以锁定它们。传递它们需要调用方的大量信任（和知识）。@Tim S.，这里的语法并不重要。认为这是假的code@Niall康诺顿：我的锁对象是
private
。它们也是静态的。因为我希望相同类型的实例“玩得很好”。但同时，让不同类型的实例在它们自己之间玩。该代码是一个伪代码。Real
genericsclass.DoSomething（\u aLock）
将更像
genericsclass.DoSomething（key，data，\u aLock）。每种不同的类型都有其关键：o）您所建议的是一种典型的情况，我已经使用了数百次。现在的问题是，我希望泛型类是一个。。通用的它应该存储和检索一些对象所需的缓存。但每个对象都有自己的缓存。我希望每种类型的实例检索或存储数据不超过一个。一种解决方案是继承具有缓存功能的基本对象。但现在这是不可能的。看起来我的想法得到了证实。它是
GenericClass
，锁对象是否由
T
设置关键帧？因为这样，您就可以声明
private static readonly object\u lockObject=new object（）GenericClass
中的code>，它为每个
T
提供了不同的锁对象。这是一个有趣的想法，甚至在我的情况下也可能起作用。区别在于，我的“泛型”只知道如何执行某些操作，不需要实例。这里我需要一个例子。我只是觉得，这对我来说太过分了，而不是.Net泛型的真正原因。