java - 在某些表达式中，JIT 能否将两个 volatile 读取合并为一个？

Question

假设我们有一个 volatile int a .一个线程可以

while (true) {
    a = 1;
    a = 0;
}

另一个线程可以

while (true) {
    System.out.println(a+a);
}

现在，JIT 编译器发出对应于 2*a 的程序集是否违法？而不是 a+a ?

一方面， volatile 读取的真正目的是它应该始终从内存中读取。

另一方面，两次读取之间没有同步点，所以我看不出处理 a+a 是非法的。原子地，在这种情况下，我看不到诸如 2*a 之类的优化如何会打破规范。

引用 JLS 将不胜感激。

Answer 1

简短的回答:

是的，这种优化是允许的。折叠两个顺序读取操作会产生原子序列的可观察行为，但不会显示为操作的重新排序。在单个执行线程上执行的任何操作序列都可以作为一个原子单元执行。通常，很难确保一系列操作以原子方式执行，并且很少会带来性能提升，因为大多数执行环境都会引入开销以原子方式执行项目。

在原始问题给出的示例中，所讨论的操作顺序如下:

read(a)
read(a)

以原子方式执行这些操作可保证在第一行读取的值等于在第二行读取的值。此外，这意味着在第二行读取的值是 a 中包含的值。在执行第一次读取时(反之亦然，因为根据程序的可观察执行状态，原子性的两次读取操作同时发生)。有问题的优化，即为第二次读取重用第一次读取的值，相当于编译器和/或 JIT 原子地执行序列，因此是有效的。

原来更长的答案:

Java 内存模型使用happens-before 偏序来描述操作。为了表达第一次阅读的限制 r1第二次阅读 r2的 a不能折叠，您需要表明在语义上需要在它们之间出现某些操作。
r1线程上的操作和 r2如下:

--> r(a) --> r(a) --> add -->

表达某些东西(比如 y )介于 r1 之间的要求和 r2 ，您需要要求 r1发生在 y 和 y发生在 r2 .碰巧的是，没有规则出现在happens-before 关系的左侧的读操作。你能得到的最接近的是说 y发生在 r2 ，但偏序允许 y也发生在 r1 之前，从而折叠读取操作。

如果不存在需要操作介于 r1 之间的场景和 r2 ，那么您可以声明在 r1 之间不会出现任何操作和 r2并且不违反语言所需的语义。使用单个读取操作将等同于此声明。

编辑 我的答案被否决了，所以我将进入更多细节。

以下是一些相关问题:

是否需要 Java 编译器或 JVM 来折叠这些读取操作？

不。表达式a和 a add 表达式中使用的不是常量表达式，因此不需要折叠它们。

JVM 是否会折叠这些读取操作？

对此，我不确定答案。通过编译程序并使用 javap -c ，很容易看出Java编译器并没有折叠这些读取操作。不幸的是，要证明 JVM 不会破坏操作(甚至更难的是处理器本身)并不容易。

JVM 应该折叠这些读取操作吗？

可能不是。每个优化都需要时间来执行，因此在分析代码所需的时间和您期望获得的好处之间存在平衡。一些优化，例如消除数组边界检查或检查空引用，已被证明对实际应用程序具有广泛的好处。这种特定优化有可能提高性能的唯一情况是两个相同的读取操作顺序出现的情况。

此外，如对此答案的响应以及其他答案所示，此特定更改将导致用户可能不希望的某些应用程序的意外行为更改。

编辑 2:关于 Rafael 对无法重新排序的两个读取操作的声明的描述。此语句旨在突出缓存 a 的读取操作这一事实。按照以下顺序可能会产生不正确的结果:

a1 = read(a)
b1 = read(b)
a2 = read(a)
result = op(a1, b1, a2)

假设最初 a和 b有它们的默认值 0。然后你只执行第一个 read(a) .

现在假设另一个线程执行以下序列:

a = 1
b = 1

最后，假设第一个线程执行行 read(b) .如果您要缓存 a 的原始读取值，你会得到以下调用:

op(0, 1, 0)

这是不正确的。自更新值 a在写入 b 之前已存储，没有办法读取值 b1 = 1然后读取值 a2 = 0 .如果没有缓存，正确的事件顺序会导致以下调用。

op(0, 1, 1)

但是，如果您问“是否有任何方法可以缓存 a 的读取？”，答案是肯定的。如果您可以将第一个线程序列中的所有三个读取操作作为原子单元执行，则允许缓存该值。虽然跨多个变量进行同步很困难并且很少提供机会优化优势，但遇到异常当然是可以想象的。例如，假设 a和 b每个是 4 个字节，它们以 a 顺序出现在内存中在 8 字节边界上对齐。 64 位进程可以实现序列 read(a) read(b)作为原子 64 位加载操作，这将允许值 a被缓存(有效地将所有三个读取操作视为原子操作，而不仅仅是前两个)。