理解 Java 内存模型的因果性约束

理解 Java 内存模型的因果性约束

欢迎讨论

欢迎加入技术交流群186233599讨论交流，也欢迎关注笔者公众号：风火说。

规范理解

这部分的内容比较抽象，首先是一开始的定义，以下

红色下划线的内容应该是理解的关键。首先，E 是一个特定的执行序列，其由指令集合 A 以及用于对集合 A 内部存在的 PO，SO，SW，HB 排序构成。C_i 是被 E 包含的一个子集，也就是说 C_i 中的指令所有都在执行 E 的指令集合 A 中存在。

来看第二，第三和第四个红线（忽略A是无限集合的状况，无限集合意味着线程出现了死循环，永不终止，这并非一个合理的程序），这三者合在一块儿理解，能够认为是 C_i 增长一个指令，就构成了 C_i+1，也就造成了新的 A_i+1 。而新的 A_i+1 结合 PO,SO,SW,HB 关系就成为了新的 E_i+1 。

接着来看后续的定义

这 5 个约束合在一块儿其实是说明如何构成一个 C 集合。简单而言，C_i 是 A_i的一个子集，而且这个子集和执行轨迹E_i 拥有相同的 HB，SO 关系，且 C_i 中写入操做的写入值和 E_i 中相同，C_i 中对写入值的观察结果和 E_i 中相同。而 E_i 是逐步构成 E 的第 i 步骤，最终 E~n~ 等同于 E 。这实际上约束了 C 是如何构成的，它并非凭空而来，而是不断的将 E 中的指令添加到 C 之中，而且这些添加的指令都和 E 拥有相关的观察效果，写入值，以及偏序关系。经过确保一系列的 E_i 都是合法的，最终肯定 E 是合法的。

再来剩下的两条规则

第 6 条规则定义了要往集合 C 中添加读取指令时，该指令的观察结果。换句话说集合 C~i-1~ 中的写入操做产生的效果，能被任意未添加到该集合中的写入操做观察到。

第 7 条规则和上面的 5 条规则相同，也是在明确在集合 C 中产生的观察效果在执行轨迹 E 中也是存在的。

7个规则都在描述在集合 C 中的写入值，读取结果，指令排列顺序都是和 E 等同，所以经过不断的构建 C_i ，最终 C~n~ 等同于 A~n~ ，再加上在 C~n~ 中的写入值，读取结果，指令排列顺序，就构成了最终的 E 。而若是这一系列的 C_i 都是“合法”的话，则最终的执行轨迹 E 也是合法的。

当咱们须要向集合新增一个读取指令时，其读取到的值只能在该集合中的写入值。提交指令到集合中时，若是存在HB 关系 或依赖关系的语句阻止其提交，则提交不能成功。

例子练习

例子1

首先来看一段代码，以下

nonvolatile global int a = 0, b = 0;
ThreadA()
{
    int aL = a;
    if(aL == 1) b = 1;
}
ThreadB()
{
    int bL = b;
    if(bL == 1) a = 1;
}
复制代码

对于内存模型而言，其只关注操做内存的指令，在执行轨迹 E 的 A 集合的内容是

int aL = a;
b = 1;
bL = b;
a = 1;
复制代码

因为int aL = a;和a = 1;不存在 HB 关系，所以能够经过数据竞争的方式读取到该写入值，也就是aL的值是 1 。bL = b;和b = 1;不存在 HB 关系，所以能够经过数据竞争的方式读取到该写入值，也就是bL的值是 1 。

一个读取操做能够读取的到值或者是经过 HB 关系获得，或者是经过数据竞争获得。也就是说，在没有 HB 关系阻止该读取结果时，该读取结果是容许的，这被称之为 HB 一致性。显然，上面的输出结果aL==bL==1是符合 HB 一致性的。

然而从顺序一致性执行的角度而言，这种输出结果就好像是由于aL读取到线程 B 写入的值，产生了b=1的结果，而这个结果致使了bL==1的结果，而这个结果致使了a=1的结果，而a==1致使了aL=1。造成了一个循环，显然这是违背直觉的。而 JMM 中因果性的要求就是用来断定这种执行轨迹是否合法的依据。

再用因果性分析这个执行以前，咱们先看另一个更简单一些的例子，代码以下

0: x == y == 0
 
Thread 1:
1: r1 = x;
2: y = 1;
 
Thread 2:
3: r2 = y;
4: x = r2;
复制代码

这个例子反复出现，显然咱们知道r1==r2==1是一个合法的输出结果。由于重排序的缘由，y=1被执行，然后r2=y观察到这个写入，x=r2一样获得值 1，r1=x观察到这个写入。下面咱们使用因果性来分析这个执行轨迹。

首先咱们将集合 C 中添加指令 2 。与指令 2 存在 HB 关系的是指令 0 和 1 。他们都不会阻止指令 2 的发生，所以指令 2 被容许添加到集合 C 中，此时有 C₁ 。

咱们用 W(variable,value) 来表达对一个变量 variable 写入 value 的值，用 R(variable,value) 表达从变量 variable 中读取到 value 的值。

所以目前咱们有 C₀= {W(x,0),W(y,0)} 的初始状态。而 C₁=C₀ U {W(y,1)} 。而后咱们添加指令 3 到 C₁ 中，按照 HB 关系，指令观察到的值应该是指令 0 写入的。可是同时，它也容许观察到提交集合中已经写入的值，也就是存在于提交集合中指令 2 的写入值。所以咱们有 C₂=C₁ U {R(y,1)} 。

接着咱们提交指令 4 ，显然此时有 C₃=C₂ U {W(x,1)} 。

最后咱们提交指令 1，按照 HB 关系，此时容许的观察值由指令 0 写入，也就是 0 。与上述相同，容许其观察到在提交集合中的写入值，所以 C₄=C₃ U {R(x,1)} 。

C₄=A₄，C₄ 中的写入值，读取值，排列顺序都与 E₄ 相同，也与 E 相同。所以断定该执行轨迹是合法的，其表现是符合 JMM 要求的。

接下来咱们回到最开始的例子，若是咱们要获得bL==1的结果，意味着咱们须要执行b=1这个指令。而要执行该指令，咱们须要执行int aL = a;指令而且读取到值 1 。注意，因果性的判断是须要考虑条件判断因素的，而 HB 一致性则不考虑，它仅仅是提取全部的可能执行指令而且假定其执行。

从提交集合的角度出发，咱们须要提交int aL = a;其实是想提交 R(a,1) 。可是 C₀={W(x,0),W(y,0)} ，C₁ 中的读取操做的读取值只能由 C₀ 中的写入形成，所以 R(a,1) 没法被提交到 C₁ 中。这就意味着达成a==b==1的提交集合不合法，所以对应的执行轨迹也是非法的。因此这种结果不被 JMM 容许。

例子2

int /* non-volatile */ a;
int /* non-volatile */ b;
ThreadA()
{
    int tmp = a;
    b = tmp;
}
ThreadB()
{
    int tmp = b;
    a = tmp;
}
复制代码

对于上面的代码，a==b==1的结果是符合 HB 一致性的。看起来这个比例子 1 中出现的状况更费解一些，由于 1 这个值彷佛是无中生有的。可是咱们首先假设int tmp = a;读取到了 1 ，此时b = tmp;将会写入 1 。而int tmp = b;又读取到了该值，这会致使a = tmp;写入值 1 ，偏偏知足了int tmp = a;读取到 1 的须要。HB 一致性中，若是没有 HB 关系阻止一个值被读取，则该读取都是被容许的，也就是能够认为int tmp = a;经过数据竞争的方式读取到了将来的写入值。按照这种方式考虑，这个例子实际上相似于例子1中的第二个示例。

可是显然，这个结果是违反直觉的，其结果也被 JMM 禁止。咱们使用因果性的方式进行分析。

首先，显然咱们有 C₀={W(a,0),W(b,0)} 。接着咱们提交int tmp = a;（不能先提交b = tmp;是由于int tmp = a;与其存在依赖关系，且有 HB 关系）。根据 C₀ 的内容，显然此时只容许提交 R(a,0) 或 R(b,0) 。经过因果性分析，咱们获得这个例子的合法输出只能是a==b==1。

总结

非正式的说，能够认为经过结合 HB 一致性和因果性要求获得 JMM 。这两个约束结合在一块儿，才有了 JMM 对程序员的保证：若是一个程序是正确同步的，其程序表现为顺序一致性。