Happens-before 使用不同的显示器

Question

在这个网站上的某个地方（我不记得这个问题）有人声称，对于不同的监视器和不同的易失性变量，发生之前发生的关系，即

// Thread T1
synchronized(O1)
{
}

// Thread T2
synchronized(O2)
{
}

如果线程 T1 在线程 T1 离开 synchronized(O1){} 块后进入 synchronized(O2){} 块，T2 将看到 T1 所做的所有更改。解释是当线程离开同步块（或写入 volatile 变量）时，它会将其缓存刷新到内存中。当一个线程进入同步块（或读取 volatile 变量）时，它会丢弃它的缓存并从内存中读取。是真的吗？

Answer 1

使用synchronized 或volatile 所产生的记忆效应就是——记忆效应。观察到内存“从缓存中刷新”的事实与synchronized 或volatile 没有直接关系。 Happens-before 关系仅在操作是由于JLS 17.4.5 中指定的操作或由于位于 happens-before 链中（即搭载) 与这些变量。如果您对不同的变量执行两个 synchronized 或 volatile 操作，则存在 NO happens-before 关系。

记忆效应是由 happens-before 排序产生的，但 happens-before 绝不是记忆效应的结果。

Answer 2

在 volatile 变量的关系为真之前发生。如果在保持关系之前发生同步块，以防您锁定同一对象。在您的情况下，同步用于不同的对象，这意味着 2 个不同的线程可以进入两个不同的同步块。在这种情况下，java 内存模型不保证发生在关系之前。

Answer 3

不同的监视器之间没有同步关系。

获取锁与后续执行之间存在happens-before关系，执行与后续锁释放之间存在happens-before关系。

如果一个线程在另一个线程离开同步块之后进入同步块，则在前一个线程上执行同步块和在后一个线程上执行同步块之间可能存在先发生关系。

您只能确定同步块是否或何时不与 synchronizes-with 关系同时运行。没有这种关系，你就会有数据竞争。

如果您显示的代码是线程之间的全部，则没有同步关系，因此没有发生之前的关系。答案的其余部分显示了代码比问题中提供的代码更多的情况。

建立同步关系的一件事是加入一个线程，例如等待前一个线程完成。另一种是启动一个线程，比如前一个线程完成后启动后一个线程。

// In a thread
t1.start();
t1.join();
t2.start();

// Or in thread 1
synchronized (O1) {
    // actions in thread 1
}
t2.start();

// Or in thread 2
t1.join();
synchronized (O2) {
    // actions in thread 2
}

或者如果后一个线程正在获取前一个线程拥有的外部锁（最终被释放）：

// in thread 1
synchronized (outerLock) {
    synchronized (O1) {
        // actions in thread 1
    }
}

// in thread 2
synchronized (outerLock) {
    synchronized (O2) {
        // actions in thread 2
    }
}

或者如果后一个线程正在等待前一个线程可验证地通知的锁（最终）：

boolean done;

// in thread 1
synchronized (O1) {
    // actions in thread 1
}
synchronized (commonLock) {
    done = true;
    commonLock.notify();
}

// in thread 2
synchronized (commonLock) {
    while (!done) {
        commonLock.wait();
    }
}
synchronized (O2) {
    // actions in thread 2
}

或者如果后一个线程读取前一个线程写入的 volatile 变量：

volatile boolean done;

// in thread 1
synchronized (O1) {
    // actions in thread 1
}
done = true;

// in thread 2
while (!done) {
    Thread.yield();
}
synchronized (O2) {
    // actions in thread 2
}

在这种特殊情况下，线程 2 仅在线程 1 写入 done 后，如果它观察到变化，它才确定它已读取 done。

实际上，所有这些情况都有 synchronizes-with 关系，因此也就是happens-before 关系。同步动作是保证总顺序的动作，所以并不是所有的happens-before关系都在线程之间。

在Java Language Specification 8th Edition §17，您可以阅读有关同步操作的信息：

同步顺序是执行的所有同步操作的总顺序。

您可以阅读以下关于发生前关系的内容：

应该注意的是，两个动作之间存在 happens-before 关系并不一定意味着它们必须在实现中以该顺序发生。如果重新排序产生与合法执行一致的结果，则不是非法的。

这允许在单个线程中，将非易失性读取重新排序至最近一次获取之后，并将非易失性写入重新排序至下一个版本之前。

所以，如果你从中取出一些东西：

• synchronizes-with 关系是关于多线程的

• 并非所有的happens-before关系都是关于多线程的