来，跟我一起干掉“final”

1. 在构造函数内对一个 final 域的写入，与随后把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序。

2. 初次读一个包含 final 域的对象的引用，与随后初次读这个 final 域，这两个操作之间不能重排序。

 
 public class FinalExample { int i; // 普通变量 final int j; //final 变量 static FinalExample obj; public void 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 域 }
      
}

写 final 域的重排序规则

• JMM 禁止编译器把 final 域的写重排序到构造函数之外。

• 编译器会在 final 域的写之后，构造函数 return 之前，插入一个 StoreStore 屏障。这个屏障禁止处理器把 final 域的写重排序到构造函数之外。

1. 构造一个 FinalExample 类型的对象；

2. 把这个对象的引用赋值给引用变量 obj。

读 final 域的重排序规则

• 在一个线程中，初次读对象引用与初次读该对象包含的 final 域，JMM 禁止处理器重排序这两个操作（注意，这个规则仅仅针对处理器）。编译器会在读 final 域操作的前面插入一个 LoadLoad 屏障。

1. 初次读引用变量 obj;

2. 初次读引用变量 obj 指向对象的普通域 j。

3. 初次读引用变量 obj 指向对象的 final 域 i。

# 如果 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 writerTwo () { // 写线程 B 执行 obj.intArray[ 0] = 2; //4 } public static void reader () { // 读线程 C 执行 if (obj != null) { //5 int temp1 = obj.intArray[ 0]; //6 }
      
  }
      
}

1. 在构造函数内对一个 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 }
      
  }
      
}

# final 语义在处理器中的实现

JSR-133 为什么要增强 final 的语义

来源：https://urlify.cn/ruYFJv