Java JMM：为什么这个结果是非法的

首先，让我们记住volatile在Java中是如何工作的.

In Java all volatile reads and writes happen in a global order in runtime (i.e. synchronization order in JLS 17.4.4).
Properties of this global order:

• 它保留每个线程的易失性读/写顺序(就JLS 17.4.4it is consistent with the program order而言)
• 每次执行一个:在同一程序的不同执行中，来自不同线程的操作可以不同地交织

易失性读取始终返回对此变量的最后一次易失性写入(按此全局顺序)(即，JLS 17.4.4中的synchronizes-with).

其次，让我们澄清一下，"增量不是原子操作"意味着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的易失性读写的方式:

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

在此图中:

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

请注意:

• w始终将the same thread中前一个r的值加1
• r始终返回the global order中前一个w写入的值

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

但是，不是有一个能产生1个的死刑吗？我绝对想不出有什么.但为什么真的没有呢？

1. look at the last write in the global order w₂₉: it always writes (the value read by r₂₈)+1
   (BTW the last write in the global order will always be either the last write w₁₉ in Thread1 or the last write w₂₉ in Thread2; in this case it's w₂₉, but for w₁₉ the reasoning is the same)

2. r₂₈始终以全局顺序读取上一次写入，即:

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

   In any case r₂₈ always returns some previous non-initial write.
   But every non-initial write always writes at least 1.
   That means w₂₉ always writes at least 2.