c# - 关于锁的一些令人困惑的事情

Question

我知道如何在我的应用程序中使用锁，但仍然有几件事我不太了解锁定(顺便说一句 - 我知道 lock 语句只是使用 Monitor 类类型的速记符号)。

来自 http://msdn.microsoft.com/en-us/library/ms173179.aspx :

 public class TestThreading
 {
     private System.Object lockThis = new System.Object();

     public void Function()
     {

         lock (lockThis)
         {
            // Access thread-sensitive resources.
         }
     }
  }

The argument provided to the lock keyword must be an object based on a reference type, and is used to define the scope of the lock. In the example above, the lock scope is limited to this function because no references to the object lockThis exist outside the function. If such a reference did exist, lock scope would extend to that object.

a) 不明白 lockThis 对象是如何定义锁的作用域的。锁的范围是 之间的所有代码锁(锁这个){ 和相邻 } ，那么“锁定范围将扩展到该对象”究竟是什么意思？

b) 锁定对象锁定这个术语是什么意思？简单地说，我们使用对 lockThis 的引用来锁定代码区域？因此，该术语并不表示我们锁定了 lockThis 对象？

谢谢

回复大卫莫顿:

如果我的回答有点冗长，我深表歉意，但我想不出任何其他方式来表达我的问题并且仍然有些连贯:

1. The scope of the lock, in this situation, is the individual instance of the class itself. This is opposed to crossing all instance of the specific class. You could have your lock cross all instances TestThreading by making lockThis static. That's what's meant by the "scope" of the lock: whether it's applicable to a single instance, or applicable to every instance of a particular type.

Other objects could still access lockThis from another thread, but they wouldn't be able to process code that is surrounded by a lock on that object.

如果我们调用被锁包围的代码(位于 TestThreading.Function 内) C ，那么由于 TestThreading.Function 不是静态的，每个 TestThreading 实例都有自己的副本 C .但是如果 TestThreading.Function 是静态的，那么所有 TestThreading 实例将共享 的相同副本。 C .打个比方，如果 C 是一个房间，如果 TestThreading.Function 不是静态的，那么每个 TestThreading 实例都会有自己的 C室 ，但如果函数是静态的，那么所有 TestThreading 实例将共享相同的 C室 .

按照这个类比，我将 lockThis 解释为 的 key 。 C室 .如果 lockThis 是静态的并且 TestThreading.Function 不是静态的，那么所有的 TestThreading 实例将使用相同的键来输入它们自己的 C房 .

因此，我认为 lockThis 是否为静态没有任何意义，因为在任何一种情况下，每个 TestThreading 实例都将使用 lockThis 进入自己的房间 C(假设 TestThreading.Function 不是 static )。因此，按照该逻辑，锁的范围不应该始终是类的单个实例(假设 TestThreading.Function 不是 static )？

同样，我认为 lockThis 是私有(private)的还是公共(public)的没有任何意义，因为 TestThreading 实例将再次使用 lockThis 进入自己的 C室 (假设 TestThreading.Function 不是静态的)

对大卫·莫顿的第二次回复

In response to your response: There is a significance. If TestThreading.Function is static, then lockThis has to be static, otherwise, TestThreading.Function cannot access lockThis at all.

我不确定您所说的 TestThreading.Function 无法访问 lockThis 是什么意思？!再次假设我们调用由锁包围的代码(位于 TestThreading.Function 内) C .
如果 TestThreading.Function 是静态的，因此只有一个房间，但是 lockThis 是非静态的，如果我们有以下定义:

 public class TestThreading
 {
    private System.Object lockThis = new System.Object();

    public static  void Function()
    {

        lock (new TestThreading().lockThis)
        {
           // Access thread-sensitive resources.
        }
    }
 }

,然后每当某个线程访问 C室 ，它将使用新 key 。因此，如果 100 个线程访问 C室 ，那么同一个房间会用 100 个不同的 key 打开？!所以代码确实有效，只是没有多大意义，因为线程之间根本没有同步？!

The scope of the lock, in this situation, is the individual instance of the class itself. This is opposed to crossing all instance of the specific class. You could have your lock cross all instances TestThreading by making lockThis static.

我对锁的作用域这个术语感到困惑，因为我将它解释为:如果 lockThis 是静态的，那么所有 TestThread 实例将共享同一个房间(又名锁)，即使 TestThread.Function 不是静态的。假设我现在理解正确，那么术语锁是指用于打开门的 key (因此锁不是指房间？!)？

因此，如果我们假设 lockThis 是静态的，而 TestThread.Function 不是静态的，那么 key/lock 的范围是所有 TestThread 实例，这意味着所有 TestThread 实例共享相同的 key ，因此当一个 TestThread 实例打开门时使用这把 key 进入它的房间，在第一个实例释放那把 key 之前，其他实例将无法打开他们房间的门？

对大卫·莫顿的第三次回复

No, if Function is static, then all TestThread instances would share the same room, if lockThis is static, then all TestThread instances would share the same key.

您是否同意在 lock 的句子范围中使用的单词 lock 至少在某种程度上指的是 key(key 是 lockThis 实例)？

The room is the code that is executed within the lock, not the lockThis object itself, that's simply the key.

【防御模式开启】我上次回复就是这么说的。 ;) [防御模式关闭]

Answer 1

在这种情况下，锁的范围是类本身的单个实例。这与跨越特定类的所有实例相反。您可以通过将 lockThis 设为静态来让您的锁跨越所有 TestThreading 实例。这就是锁的“范围”的含义:它是适用于单个实例，还是适用于特定类型的每个实例。

“锁定对象 thisObject”只是意味着使用 thisObject 作为确定我们是否处于锁定状态的对象。该术语并不表示我们“锁定”了 lockThis 对象。我认为你的估计在这里是正确的。其他对象仍然可以从另一个线程访问 lockThis，但它们将无法处理被该对象上的锁包围的代码。

由于我们正在相互回复，这里有更多信息:

让我们以您上面概述的“房间和 key ”类比，并将其扩展到每一种可能性。我们有几种不同的情况:

静态函数，静态锁对象——这类似于有一个房间，只有一把 key 。

实例函数，静态锁对象 - 这就像有几个房间共享相同的 key ......例如，就像一个万能 key 。

实例函数，实例锁对象 - 这就像有几个房间，每个房间都有自己的 key ......就像宿舍或酒店。

静态函数，实例锁定对象 - 不可能。您无法从静态上下文访问实例字段。

希望上述场景概述了这些将如何协同工作。

回复第二个回复

I’m not sure what you mean by TestThreading.Function not being able to access lockThis?!

它无法访问有用的 lockThis。锁定完成后被丢弃的实例上的静态方法锁定是无用的。在您设置的场景中，每次靠近门时，锁都会“赠送”一把新 key ，并说“好吧，我接受刚刚给您的 key ……您可以进来”。在这种情况下，它过于松散地保护“房间”，让每个人都可以随时访问。换句话说，在第二个示例中甚至没有理由使用 lock 语句。这就像房间里有数量不断增加的门，只用过一次，上面贴着 key 。无数人可以随时进入。您的代码和以下代码之间没有区别，真的(有，但这是为了让您有希望获得这个概念:

public class TestThreading
{
    private object lockThis = new object();

    public static void Function() 
    {
        lockThis = new object();
        lock (lockThis)
        {
            // access something   
        }
    }
}

我在上面那个例子中所做的基本上是在我在门上使用锁之前扔掉并重新 key 。那没用。你是对的，不会有任何线程同步，从这个意义上说，我会说代码根本不起作用，因为锁的全部意义在于同步线程。

if the lockThis was static, then all TestThread instances would share the same room (aka lock), even though TestThread.Function isn’t static. Assuming I understand it correctly now, then the term lock is referring to the key (thus lock doesn’t refer to the room?! ) used for opening the doors?

不，如果 Function 是静态的，那么所有 TestThread 实例将共享同一个房间，如果 lockThis 是静态的，那么所有 TestThread 实例将共享相同的 key 。

lock (key)
{
   // room
}

房间是在锁内执行的代码，而不是 lockThis 对象本身，那只是 key 。

As such, if we assume that lockThis is static and TestThread.Function is not static, then the scope of the key/lock is all TestThread instances, which means that all TestThread instances share the same key and thus when one TestThread instance opens the door to its room using this key, the other instances won’t be able to open the doors to their rooms until first instance releases that key?

是的。