java - JMM : Why this outcome is illegal?

Question

我最近偶然发现了 this jcstress 中的示例:

@JCStressTest
@State
@Outcome(id = "10",                      expect = ACCEPTABLE,             desc = "Boring")
@Outcome(id = {"0", "1"},                expect = FORBIDDEN,              desc = "Boring")
@Outcome(id = {"9", "8", "7", "6", "5"}, expect = ACCEPTABLE,             desc = "Okay")
@Outcome(                                expect = ACCEPTABLE_INTERESTING, desc = "Whoa")
public static class Volatiles {
    volatile int x;

    @Actor
    void actor1() {
        for (int i = 0; i < 5; i++) {
            x++;
        }
    }

    @Actor
    void actor2() {
        for (int i = 0; i < 5; i++) {
            x++;
        }
    }

    @Arbiter
    public void arbiter(I_Result r) {
        r.r1 = x;
    }
}

作者强调，由于增量不是原子操作，因此不能指望每次循环迭代仅“丢失”一个增量更新。因此，除了 0 和 1 之外的所有结果(最多 10)都是允许的(并且确实发生了)。

我明白为什么 0 是不允许的:在对象默认值的初始化和每个线程中的第一个操作之间有一个 HB 边缘，如 JLS 中所述。 JLS 17.4.4

The write of the default value (zero, false, or null) to each variable synchronizes-with the first action in every thread.

作者还解释了如何得到结果 2:

The most interesting result, "2" can be explained by this interleaving:
        Thread 1: (0 ------ stalled -------> 1)     (1->2)(2->3)(3->4)(4->5)
        Thread 2:   (0->1)(1->2)(2->3)(3->4)    (1 -------- stalled ---------> 2)

我知道你不能像这样“扩展”上面的解释:

        Thread 1: (0 --------- stalled -----------> 1)     (1->2)(2->3)(3->4)(4->5)
        Thread 2:   (0->1)(1->2)(2->3)(3->4)(4->5)

因为它导致结果 5。但是难道没有一个会产生1 的执行吗？我绝对想不出任何一个。但为什么实际上没有呢？

Answer 1

首先，让我们记忆一下 volatile 在 Java 中是如何工作的。

在 Java 中，所有 volatile 读取和写入在运行时以全局顺序发生(即 JLS 17.4.4 中的同步顺序)。
此全局顺序的属性:

• 它保留了每个线程的 volatile 读/写顺序(根据 JLS 17.4.4 它与程序顺序一致)
• 每次执行一个:来自不同线程的操作可以在同一程序的不同执行中以不同方式交错

volatile 读取总是返回对该变量的最后一次(按此全局顺序) volatile 写入(即 同步 在 JLS 17.4.4 中)。

其次，让我们澄清一下“增量不是原子操作”意味着x++由3个原子操作组成:

var temp = x;     // volatile read of 'x' to local variable 'temp'
temp = temp + 1;  // increment of local variable 'temp'
x = temp;         // volatile write to `x`

最后，让我们重写

The most interesting result, "2" can be explained by this interleaving:
        Thread 1: (0 ------ stalled -------> 1)     (1->2)(2->3)(3->4)(4->5)
        Thread 2:   (0->1)(1->2)(2->3)(3->4)    (1 -------- stalled ---------> 2)

以一种显示对 x 的 volatile 读取和写入的方式:

Thread1    Thread2
r₁₀:0                  | global
            r₂₀:0      | order of
            w₂₁:1      | volatile
            r₂₂:1      | reads
            w₂₃:2      | and
            r₂₄:2      | writes
            w₂₅:3      V
            r₂₆:3
            w₂₇:4
w₁₁:1
            r₂₈:1
r₁₂:1
w₁₃:2
r₁₄:2
w₁₅:3
r₁₆:3
w₁₇:4
r₁₈:4
w₁₉:5
            w₂₉:2

在这张图上:

• volatile 读写的全局顺序是从上到下
• r:1 是对 x 的 volatile 读取，它返回 1
• w:1 是 1 到 x
的 volatile 写入

注意:

• w总是在同一个线程中写入前一个r的值加1
• r 始终返回全局顺序中前一个w写入的值

现在我们可以回答您的问题了:

But isn't there an execution that will produce 1? I definitely can't think of any. But why there actually is none?

1. 查看全局顺序w₂₉中的最后一次写入:它总是写入(r₂₈读取的值)+1
   (顺便说一句，全局顺序中的最后一次写入将始终是 Thread1 中的最后一次写入 w₁₉ 或 Thread2 中的最后一次写入 w₂₉；在这种情况下，它是 w₂₉，但对于 w₁₉，推理是相同的)

2. r₂₈ 总是按照全局顺序读取之前写入的，即:

   • 来自同一线程的w₂₇
   • 或者一些从 Thread1 写入 w₁ₓ(如果 w₁ₓ 在运行时发生在 w₂₇ 和 r₂₈ 之间)

   在任何情况下，r₂₈ 总是返回一些先前的非初始写入。
   但是每次非初始写入总是至少写入 1。
   这意味着 w₂₉ 总是至少写入 2。