参考地址：https://blog.csdn.net/dam454450872/article/details/80385520
对应final域，编译器和处理器需要遵守两个重排序规则
①在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序--对应写final域
②初次读一个包含final域的对象的引用，域随后初次读这个final域，这两个操作之间不能重排序--对应读final域
实例代码：
public class FinalExample {
int i; // 普通变量
final int j; // final变量
static FinalExample obj;
public FinalExample() { // 构造函数
i = 1; // 写普通域
j = 2; // 写final域
}
public static void writer() {// 写线程A执行
obj = new FinalExample();
}
public static void reader() { // 读线程B执行
FinalExample object = obj; // 读对象引用
int a = object.i; // 读普通域
int b = object.j; // 读final域
}
}
假设一个线程A执行writer()方法，随后另一个线程执行B执行reader()方法，通过两个线程的交互说明上面的两个规则。
写final域的重排序规则禁止把final域的写重排序到构造函数之外。
具体包含两个方面：
①JMM禁止编译器把final域的写重排序到构造函数之外。
②编译器会在final域的写之后，构造函数return之前，插入一个StoreStore屏障。该屏障禁止处理器把final域的写重排序到构造函数之外。
看write()方法，只包含一行代码 finalExample = new FinalExample()。这一行代码包含两个步骤：
①构造一个FinalExample类型的对象。
②把这个对象的引用赋值给引用变量obj。
假设线程B读对象引用（FinalExample object = obj）与读对象的成员域之间（int a = object.i;int b = object.j）没有重排序，下面的图是一种可能的执行时序：
从上面可能的时序图中我们可以看到，写普通域被编译器重排序到了构造函数之外，读线程B错误的读取了普通变量i初始化之前的值。写final域的操作，被写final域的重排序规则“限制”到了构造函数之内，读线程B正确读取了final变量初始化之后的值。
即读线程B读取对象引用obj时，obj很可能没有构造完成，对普通域i的写操作被重排序到构造函数之外，初始值1还没有被写入到普通域i。
总结：写final域的重排序规则可以确保在对象引用为任意线程可见之前，对象的final域已经被正常的初始化了，而普通域不具有这样的保证。
读final域的重排序规则是，在一个线程中，初次读对象引用与初次读该对象包含的final域，JMM（Java的并发采用的是共享内存模型）禁止处理器重排序这两个操作（仅仅针对处理器）。编译器会在读final域操作的前面插入一个LoadLoad屏障。
初次读对象的引用与初次读该对象包含的final域，这两个操作之间存在间接依赖关系。编译器遵守间接依赖关系，因此编译器不会重排序这两个操作。大多数处理器也会遵守间接依赖，但有个别处理器允许对存在间接依赖关系的操作做重排序（如alpha处理器），所以说这个读final域的重排序规则就是专门针对这种处理器。
reader()方法包含3个步骤：
①初次读引用变量obj
②初次读引用变量obj指向对象的普通域 i
③初次读引用变量obj指向对象的final域 j
我们假设写线程A没有发生任何重排序，同时程序在不遵守间接依赖的处理器上执行，则下图是一种可能的时序：
从上图可以看出，读对象的普通域的操作被处理器重排序到读对象引用之前。读普通域时，该域还没有被线程A写入，所以上面的是一个错误的读取操作。但是读final域的重排序规则把读对象final域的操作“限定”在读对象引用之后，该final域已经被A线程初始化了，是一个正确的读取操作。
小结：读final域的重排序规则可以确保在读一个对象的final域之前，一定会先读包含这个final域的对象的引用。
下面说一下final域是引用类型的情况
public class FinalReferenceExample {
final int[] intArray; // final 是引用类型
static FinalReferenceExample obj;
public FinalReferenceExample() { // 构造函数
intArray = new int[1]; // 1
intArray[0] = 1; // 2
}
public static void writerOne() { // 写线程A执行
obj = new FinalReferenceExample();// 3
}
public static void writeTwo() { // 写线程B执行
obj.intArray[0] = 2; // 4
}
public static void reader() { // 读线程C执行
if (obj != null) { // 5
int temp1 = obj.intArray[0];// 6
}
}
}
本例final域为数组的引用类型，写final域的重排序规则对编译器和处理器增加了如下约束：
在构造函数内对一个final引用的对象的成员域的写入，与随后在构造函数外把这个被构造对象的引用赋值给一个引用变量，这两操作之间不能进行重排序。
假设线程A执行writeOne()方法，执行完成后线程B执行writeTwo()方法，执行完成后线程C执行reader()方法，下图是一种坑你的时序：
在上图中，1是对final域的写入，2是对final域引用的对象的成员域的写入，3是把被构造的对象的引用赋值给某个引用变量。这里1和3，2和3都不能重排序。JMM可以保证读线程C至少能看到写线程A在构造函数中国对final引用对象的成员域的写入。即线程C至少能看到数组下标0的值为1。线程B对数组元素的写入，读线程C不一定能保证看到。要想保证读线程C看到线程B对数组元素的写入，写线程B和读线程C之间需要使用同步原语（lock或volatile）保证内存可见性。
通过上面的介绍，我们知道：写final域的重排序规则可以确保：在引用变量为任意线程课件之前，读引用变量的指向的对象的final域已经在构造函数中被正确初始化了。但是这里面，还需要另外一点的保证：在构造函数内部，不能让这个被构造对象的引用为其他线程所见，即对象引用不能再构造函数中“逸出”。
public class FinalReferenceEscapeExample {
final int i;
static FinalReferenceEscapeExample obj;
public FinalReferenceEscapeExample() {
i = 1; // 1 写final域
obj = this; // 2 this引用在此”逸出“
}
public static void writer() {
new FinalReferenceEscapeExample();
}
public static void reader() {
if (obj != null) { // 3
int temp = obj.i; // 4
}
}
}
假设线程A执行writer()方法，线程B执行reader()方法。这里的操作2使得对象还未完成构造前就被线程B可见。即使操作2放到了构造函数的最后一步，且在程序中操作2排在了1后面，执行reader()方法的线程仍可能无法看到final域被初始化后的值，因为操作1和操作2可能被重排序。
从上面的图可以看出：在构造函数返回前，被构造对象的引用不能为其他线程所见，因为此时的final域可能还没有被初始化。在构造函数返回后，任意线程都保证能看到final域正确初始化后的值。
上面介绍了 写final域的重排序规则会要求编译器在final域的写入后，构造函数返回之前插入一个StoreStore屏障。读final域的重排序规则要求编译器在读final域的操作前插入一个LoadLoad屏障。但X86处理器不会对 写-写操作做重排序，所以StoreStore屏障被省略。X86处理器不会对存在间接依赖关系的操作做重排序，所以读final域需要的LoadLoad屏障也会被省略。即x86处理器，final域的读写不会插入任何内存屏障。
插曲：JSR-133即JDK5开始。
在旧的JMM中，有个弊端是线程可能看到final域的值会改变。比如一个线程当前看到一个整形final域的值为0（还未初始化之前的默认值），过一段时间这个线程再读取这个final值，发现为1（被某个线程初始化之后的值），作者举了个例子是在旧的JMM中String的值可能会改变。
所以JSR-133的专家们增强了final的语义，通过给final域增加写和读重排序规则，可以提供初始化安全保证：只要对象时正确构造的（被构造对象的引用在构造函数中没有“逸出”），就不需要使用同步就可以保证在任意线程都能看到这个final域在构造函数中被初始化后的值。
原文：https://www.cnblogs.com/ltycomeon/p/13562104.html