围绕多个语句的锁定语句是否确保所有更改对其他线程可见（假设它们输入相同的互斥锁）？

Question

如果您在一个锁代码块内有多个共享变量赋值，这是否一定意味着所有这些更改对其他线程立即可见，一旦进入锁语句就可能在其他处理器上运行在同一个对象上 - 或者没有这样的保证？

那里的许多示例显示了一个单个“设置”或“获取”一个公共变量，并详细介绍了内存屏障，但是如果里面有一组更复杂的语句会发生什么?甚至可能执行其他操作的函数调用？

类似这样的：

lock(sharedObject)
{
  x = 10;
  y = 20;
  z = a + 10;
}

如果此代码在另一个线程上运行，而该线程可能在另一个处理器上执行，它是否对更改的“可见性”做出任何保证？

lock (sharedObject)
{
  if (y == 10)
  {
     // Do something. 
  }
}

如果答案是否 - 也许并说明何时这些变化可能会变得可见？

Answer 1

锁块在开始和结束（块的开始和结束）处包括内存栅栏。这确保了对内存的任何更改对其他内核（例如，在其他内核上运行的其他线程）都是可见的。在您的示例中，任何其他线程都可以看到第一个锁定块中对 x、y、z 的更改。 “可见”意味着缓存到寄存器中的任何值都将被刷新到内存中，并且任何缓存在 CPU 缓存中的内存都将被刷新到物理内存中。 ECMA 334 详细说明锁块是由 Monitor.Enter 和 Monitor.Exit 包围的块。此外，ECMA 335 详细说明 Monitor.Enter “应隐式执行易失性读取操作......”和 Monitor.Exit “隐式执行易失性写入操作。这确实意味着修改对其他内核/线程不可见，直到锁定块的末尾（在 Monitor.Exit 之后），但是如果您对这些变量的所有访问都受到锁定的保护，那么无论如何都不能跨不同的内核/线程同时访问所述变量。

这实际上意味着任何由 lock 语句保护的变量都不需要声明为 volatile 以使其修改对其他线程可见。

由于示例代码仅包含一个依赖于单个共享原子操作的操作（读取和写入单个值到 y），因此您可以通过以下方式获得相同的结果：

try
{
  x = 10;
  y = 20;
  Thread.VolatileWrite(ref z, a + 10);
}

和

if(y == 10)
{
// ...
}

第一个块保证对 x 的写入在对 y 的写入之前是可见的，对 y 的写入在对 z 的写入之前是可见的。它还保证，如果对 x 或 y 的写入缓存在 CPU 缓存中，则该缓存将在调用 VolatileWrite 后立即刷新到物理内存（因此对任何其他线程可见）。

如果在if(y == 10) 块内您使用x 和y 执行某些操作，您应该返回使用lock 关键字。

此外，以下内容相同：

try
{
  x = 10;
  y = 20;
  Thread.MemoryBarrier();
  z = a + 10;
}

Answer 2

如果我误解了你的问题，请原谅我（很有可能）；但我认为您正在混淆同步和可见性的概念。

互斥锁（“互斥”）的全部意义在于确保两个代码块不会同时运行。所以在你的例子中，第一个块：

lock(sharedObject)
{
  x = 10;
  y = 20;
  z = a + 10;
}

...和第二块：

lock (sharedObject)
{
  if (y == 10)
  {
     // Do something. 
  }
}

...永远不会同时执行。这就是 lock 关键字为您提供的保证。

因此，任何您的代码进入第二个块时，变量 x、y 和 z 应该处于与完全执行第一的。 （这是假设您在任何地方访问这些变量时，您在 sharedObject 上的 lock 与在这些 sn-ps 中的方式相同。）

这意味着第一个块中的中间更改的“可见性”与第二个块的角度无关，因为永远不会发生例如值x 的更改，但是不要y 或z。