java - 多线程场景下的数据可见性

Question

另一个场景，基于之前的问题。在我看来，它的结论足够笼统，对广大读者都有用。引用来自 here 的 Peter Lawrey :

The synchronized uses a memory barrier which ensures ALL memory is in a consistent state for that thread, whether its referenced inside the block or not.

首先，我的问题涉及仅数据可见性。也就是说，原子性(“操作同步”)在我的软件中已经得到保证，所以每个写操作都在对相同值的任何读操作之前完成，反之亦然，等等。因此，问题仅与线程可能缓存的值有关。

考虑 2 个线程，threadA 和 threadB，以及以下类:

public class SomeClass {

private final Object mLock = new Object();    
// Note: none of the member variables are volatile.

public void operationA1() {
   ... // do "ordinary" stuff with the data and methods of SomeClass

     /* "ordinary" stuff means we don't create new Threads,
         we don't perform synchronizations, create semaphores etc.
     */
}

public void operationB() {
  synchronized(mLock) {
     ...
     // do "ordinary" stuff with the data and methods of SomeClass
  }
}

// public void dummyA() {
// synchronized(mLock) {
//    dummyOperation();
//  }
// }

public void operationA2() {
   // dummyA();  // this call is commented out

   ... // do "ordinary" stuff with the data and methods of SomeClass
}
}

已知事实(它们来 self 的软件架构):

• operationA1() 和operationA2() 被threadA 调用，operationB() 被调用em>threadB
• operationB() 是该类中 threadB 调用的唯一方法。请注意，operationB() 位于同步块(synchronized block)中。
• 非常重要:保证按照以下逻辑顺序调用这些操作:operationA1(), operationB(), 操作A2()。保证每个操作在调用前一个操作之前完成。这是由于更高级别的架构同步(消息队列，但现在无关紧要)。正如我所说，我的问题完全与数据可见性相关(即数据副本是最新的还是过时的，例如由于线程自身的缓存)。

根据 Peter Lawrey 的引述，operationB() 中的内存屏障确保所有内存在 operationB()< 期间对 threadB 处于一致状态。因此，例如如果 threadA 改变了 operationA1() 中的一些值，这些值将在 threadA 的缓存中写入主内存 code>operationB() 开始。 问题 #1:这是正确的吗？

问题 #2:当 operationB() 离开内存屏障时，operationB() 更改的值(并且可能被 缓存em>threadB) 将被写回主存。 但是 operationA2() 不会安全 因为没有人要求threadA 与主存同步，对吧？所以 operationB() 的更改现在在主内存中并不重要，因为 threadA 可能仍然有 operationB( ) 被调用了。

问题 #3:如果我对 Q.#2 的怀疑是真的，那么再次检查我的源代码并取消注释方法 dummyA()，并取消注释 dummyA() 在 operationA2() 中调用。我知道这在其他方面可能是不好的做法，但这有什么不同吗？我的(可能是错误的)假设如下:dummyA() 将导致 threadA 从主内存更新其缓存数据(由于 mLock同步块(synchronized block))，因此它将看到 operationB() 完成的所有更改。也就是说，现在一切都安全了。附带说明一下，方法调用的逻辑顺序如下:

1. operationA1()
2. operationB()
3. dummyA()
4. operationA2()

我的结论:由于 operationB() 中的同步块(synchronized block)，threadB 将看到之前可能已更改的最新数据值 (例如在 operationA1() 中。由于 dummyA() 中的同步块(synchronized block)，threadA 将看到在 operationB() 中更改的最新数据副本>。这个思路有没有错误？

Answer 1

您对问题 2 的直觉通常是正确的。在操作 A2 开始时使用 synchronized(mLock) 将发出内存屏障，这将确保操作 A2 的进一步读取将看到操作 B 执行的写入，由于使用 synchronized( mLock) 在操作 B.

但是，要回答问题 1，请注意操作 B 可能看不到操作 A1 执行的任何写入，除非您在操作 A1 的末尾插入一个完整的内存屏障(即，没有任何内容告诉系统从操作 A1 线程的缓存中刷新值) .因此，您可能希望在操作 A1 结束时调用 dummyA。

为了完全安全和更易于维护，并且由于您声明这些方法的执行不会相互重叠，您应该将共享状态的所有操作包含在同步(mLock) block 中而不损失性能。