之前发生的属性如何与可见性和顺序相关？

Question

我想弄清楚发生前属性的确切含义。

我已经看到了对happens-before属性的解释说，如果全局变量（不是易失性或包含在同步块中）的更新在其他一些易失性变量之前被更改，则它们对其他线程可见，或者在同步块内改变。这是正确的吗？如果是这样，它在 java 文档中的什么地方是这样说的？

我的理解是，happens-before 属性定义了共享字段和代码执行之间的关系，例如：

• 监视器的解锁发生在同一监视器的每次后续锁定之前。
• 对 volatile 字段的写入发生在对同一字段的每次后续读取之前。
• 在线程上启动的调用发生在已启动线程中的任何操作之前。
• 线程中的所有操作都发生在任何其他线程从该线程的连接成功返回之前。

例如：

class Shared {

  private int y = 0;
  private volatile int x = 0;

  public void setOne() {
    y = 1;
    x = 1;
  }

  public int getY() {
    return y;
  }

}

对于上面的代码，给定 2 个线程：

Shared shared = new Shared();

new Thread(() -> shared.setOne()).start();
new Thread(() -> shared.getY()).start();

编辑 假设我们可以保证第一个线程已经启动，那么 getY() 会在这里返回 0 还是 1？

我还看到一些例子说这种行为只发生在读取线程中的 volatile 字段之后。因此，在这种情况下，如果一个线程读取 volatile 字段的值（假设是线程 B），那么线程 A 中在该 volatile 字段之前写入的所有字段都可用于线程 B。据此，如果我修改 getY() 方法上面的共享对象是：

  public int getXPlusY() {
    int local = x;
    return local + y;
  }

是这个动作让 y 对其他线程可见吗？

Answer 1

让我们先看看你的第二个例子。

class Shared {

  private int y = 0;
  private volatile int x = 0;

  public void setOne() {
    y = 1; //(1)
    x = 1; //(2)
  }

  public int getXPlusY() {
    int local = x; //(3)
    return local + y; //(4)
  }
}

由于程序顺序，我们知道 (1) 和 (2) 之间存在 happens-before 关系：

如果 x 和 y 是同一线程的操作，并且 x 在程序顺序中位于 y 之前，则为 hb(x, y)。

由于x 是易变的，我们知道 (2) 和 (3) 之间存在 happens-before 关系

对 volatile 字段（第 8.3.1.4 节）的写入发生在对该字段的每次后续读取之前。

由于程序顺序，(3)和(4)之间又存在happens-before关系：

如果 x 和 y 是同一线程的操作，并且 x 在程序顺序中位于 y 之前，则为 hb(x, y)。

因此，我们有一个 happens-before 链 (1) → (2), (2) → (3), (3) → (4)

并且由于 happens-before 是传递关系（如果 A 发生在 B 之前，B 发生在 C 之前，那么 A 发生在 C 之前）这意味着 (1) 有一个 happens-before 与 (4) 的关系。

现在让我们看第一个例子：

class Shared {

  private int y = 0;
  private volatile int x = 0;

  public void setOne() {
    y = 1; //(1)
    x = 1; //(2)
  }

  public int getY() {
    return y; //(3)
  }
}

在 (1) 和 (2) 之间还有 happens-before 关系，但仅此而已。因为x 没有被第二个线程读取，我们在(2) 和(3) 之间没有happens-before。因此，我们在 (1) 和 (3) 之间没有 happens-before 关系。

引用来自Chapter 17 of the Java Language Specification (JLS)

Answer 2

我将重命名这些类以使其清楚：

class First {

    private int y = 0;
    private volatile int x = 0;

    public void setOne() {
       y = 1;
       x = 1;
    }

    public int getY() {
       return y;
    }

}

你的前提是：

假设我们可以保证第一个线程已经启动

零保证getY 将返回1。只有当您遵守 JLS 的先发生规则时，才能保证对共享字段的更新对某些读取线程可见，此处不强制执行。因此，从 getY 获取 0 是完全有效的。

你的第二个例子：

class Second {

    private int y = 0;
    private volatile int x = 0;

    public void setOne() {
       y = 1;
       x = 1;
    }

    public int getXPlusY() {
       int local = x;
       return local + y;
    }

}

同样的前提是：

假设我们可以保证第一个线程已经启动

不保证返回2。对于输出2 的方法，读取线程必须观察（查看）易失性写入。那就是它必须是这样的：

 public int getXPlusY() {
   int local = x;
   if(local == 1){ // you need to see the write that was done in the other thread
      return local + y;
   }
   return local + y;    
}

如果您输入 if 语句 f(local == 1)，您已经观察到在另一个线程 (x = 1) 中完成的易失性写入，因此，您可以保证在该写入之前完成的所有内容也是可见的。这意味着在这个时间点，y = 1，当然，所以你的方法将返回2。

没有这个 if 语句，你的阅读 int local = x 是一个活泼的阅读，没有什么可以阻止这个线程在两者之间做 int local = x：

y = 1;
x = 1;

---

事实证明这也是可以证明的，这是一个 jcstress 测试，证明了另一个答案（至少 1/2）是错误的：

// https://stackoverflow.com/questions/58450777/how-does-the-happen-before-property-relate-to-visibility-and-ordering
@JCStressTest
@State
@Outcome(id = "0", expect = Expect.FORBIDDEN, desc = "can not happen")
@Outcome(id = "1", expect = Expect.FORBIDDEN, desc = "can not happen")
@Outcome(id = "2", expect = Expect.ACCEPTABLE, desc = "reader thread was done before writer did anything")
@Outcome(id = "3", expect = Expect.ACCEPTABLE_INTERESTING, desc = "racy read!!!")
@Outcome(id = "4", expect = Expect.ACCEPTABLE, desc = "reader thread sees everything that writer did")
public class VolatileRace {

    // change defaults so that "readerThread" does not output a false positive.
    // it can happen when it runs it's entire method body before "writerThread"
    // does anything at all.
    private int y = 1;
    private volatile int x = 1;

    @Actor
    public void writerThread() {
        y = 2;
        x = 2;
    }

    @Actor
    public void readerThread(I_Result result) {
        int local = x;
        result.r1 = local + y;
    }

}

这个测试的重点是，它有这样一个输出：

  0             0                FORBIDDEN  can not happen
  1             0                FORBIDDEN  can not happen
  2     4,616,926               ACCEPTABLE  reader thread was done before writer did anything
  3         6,694   ACCEPTABLE_INTERESTING  racy read!!!
  4     3,107,831               ACCEPTABLE  reader thread sees everything that writer did

即使你不明白，它也表明阅读线程已经看到3作为它的结果，这意味着它已经阅读了x = 1和y = 2。