第四章：final关键字

一、final禁⽌指令重排分析

对final域的读和写更像是普通的变量访问，编译器和处理器要遵守两个重排序规则：

• 在构造函数内对⼀个final域的写⼊，与随后把这个被构造对象的引⽤赋值给⼀个引⽤变量，这两个操作之间 不能重排序。
• 初次读⼀个包含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域
 }
}

这⾥假设⼀个线程A执⾏writer ()⽅法，随后另⼀个线程B执⾏reader ()⽅法，注意两者的调⽤先后关系！

下⾯我们通过这两个线程的交互来说明这两个规则。

二、写final域的重排序规则

写final域的重排序规则禁⽌把final域的写重排序到构造函数之外。这个规则的实现包含下⾯2个⽅⾯：

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

现在让我们分析writer ()⽅法。writer ()⽅法只包含⼀⾏代码：finalExample = new FinalExample ()。这⾏代码包 含两个步骤：

• 构造⼀个FinalExample类型的对象；
• 把这个对象的引⽤赋值给引⽤变量obj。

假设线程B读对象引⽤与读对象的成员域之间没有重排序（⻢上会说明为什么需要这个假设），下图是⼀种可能的 执⾏时序：

在上图中，写普通域的操作被编译器重排序到了构造函数之外，读线程B错误的读取了普通变量i初始化之前的值。 ⽽写final域的操作，被写final域的重排序规则“限定”在了构造函数之内，读线程B正确的读取了final变量初始化之后的值。

写final域的重排序规则可以确保：在对象引⽤为任意线程可⻅之前，对象的final域已经被正确初始化过了，⽽普通 域不具有这个保障。以上图为例，在读线程B“看到”对象引⽤obj时，很可能obj对象还没有构造完成（对普通域i的 写操作被重排序到构造函数外，此时初始值2还没有写⼊普通域i）。

总结⼀下：也就是对象初始化final变量和普通变量，然后将初始化的对象引⽤赋值给其它变量前，final变量 可以保证已经被初始化，但是普通变量不能保证，可能会导致读取的普通变量是⼀个空值，或者说是未初始 化的值，导致异常。

三、读final域的重排序规则

读final域的重排序规则如下：

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

reader()⽅法包含三个操作：

1. 初次读引⽤变量obj;
2. 初次读引⽤变量obj指向对象的普通域j。
3. 初次读引⽤变量obj指向对象的final域i。

现在我们假设写线程A没有发⽣任何重排序，同时程序在不遵守间接依赖的处理器上执⾏，下⾯是⼀种可能的执⾏时序：

在上图中，读对象的普通域的操作被处理器重排序到读对象引⽤之前。读普通域时，该域还没有被写线程A写⼊， 这是⼀个错误的读取操作。⽽读final域的重排序规则会把读对象final域的操作“限定”在读对象引⽤之后，此时该 final域已经被A线程初始化过了，这是⼀个正确的读取操作。

总结⼀下：在读⼀个对象的final变量之前，⼀定会先读包含这个final域的对象的引⽤，所以不⽤担⼼读到对 象的final变量，会因为重排除导致读到的是⼀个未初始化的值，但是对象的普通变量就不能这样保证。

对读和写finlal域，整体总结⼀下：写final域的重排序规则会要求译编器在final域的写之后，构造函数return 之前，插⼊⼀个StoreStore障屏。读final域的重排序规则要求编译器在读final域的操作前⾯插⼊⼀个 LoadLoad屏障。

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

在上图中

1是对final域的写⼊，2是对这个final域引⽤的对象的成员域的写⼊，3是把被构造的对象的引⽤赋值给 某个引⽤变量。这⾥除了前⾯提到的1不能和3重排序外，2和3也不能重排序。

JMM可以确保读线程C⾄少能看到写线程A在构造函数中对final引⽤对象的成员域的写⼊。即C⾄少能看到数组下标 0的值为1。⽽写线程B对数组元素的写⼊，读线程C可能看的到，也可能看不到。JMM不保证线程B的写⼊对读线程 C可⻅，因为写线程B和读线程C之间存在数据竞争，此时的执⾏结果不可预知。

如果想要确保读线程C看到写线程B对数组元素的写⼊，写线程B和读线程C之间需要使⽤同步原语（lock或 volatile）来确保内存可⻅性。

总结⼀下：如果final域为引⽤类型，这个其实和⾮引⽤类型禁⽌重排序的规则基本⼀样。上⾯的示例， writerTwo()和reader()同时对⼀个数据进⾏操作，存在竞争关系，也很好理解，我换⼀个⾮引⽤类型，也⼀ 样存在并发，解决⽅案就是加锁。

五、为什么final引⽤不能从构造函数内“逸出”

前⾯我们提到过，写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后⾯，执⾏read()⽅法的线程仍 然可能⽆法看到final域被初始化后的值，因为这⾥的操作1和操作2之间可能被重排序。实际的执⾏时序可能如下图 所示：

从上图我们可以看出：在构造函数返回前，被构造对象的引⽤不能为其他线程可⻅，因为此时的final域可能还没有 被初始化。在构造函数返回后，任意线程都将保证能看到final域正确初始化之后的值。

上⾯都是⼋股⽂，也很少会遇到上述使⽤场景，个⼈也仅作兴趣了解，避免踩坑，下⾯总结⼀下final的常⽤ ⽤法。

六、final关键字有⼏种⽤法

6.1 修饰普通变量

注意点：

• ⽤final关键字修饰的变量，只能进⾏⼀次赋值操作，并且在⽣存期内不可以改变它的值。final修饰的变量可 以先声明，后赋值。

6.2 修饰成员变量

注意点：

• 必须初始化值。
• 被final修饰的成员变量赋值，有两种⽅式：1、直接赋值 2、全部在构造⽅法中赋初值。
• 如果修饰的成员变量是基本类型，则表示这个变量的值不能改变。
• 如果修饰的成员变量是⼀个引⽤类型，则是说这个引⽤的地址的值不能修改，但是这个引⽤所指向的对象⾥⾯ 的内容还是可以改变的。

public class Test {
 final int age = 18;
 final String name;
 final String[] hobby;
 public Test() {
 this.name = "lvmenglou"; // 正确使⽤
 //this.age = 20; // 错误使⽤
 this.hobby = new String[4]; // 正确使⽤
 this.hobby[0] = "movie"; // 正确使⽤
 this.hobby[1] = "sing song"; // 正确使⽤
 }
}

6.3 修饰⽅法

注意点：

• 被final修饰的⽅法不能被重写。
• ⼀个类的private⽅法会隐式的被指定为final⽅法。
• 如果⽗类中有final修饰的⽅法，那么⼦类不能去重写。

6.4 修饰类

注意点：

• ⽤final去修饰⼀个类的时候，表示这个类不能被继承；
• final类中的成员⽅法都会被隐式的指定为final⽅法；
• 被final修饰的类，final类中的成员变量可以根据⾃⼰的实际需要设计为final。

在⾃⼰设计⼀个类的时候，要想好这个类将来是否会被继承，如果可以被继承，则该类不能使⽤final修饰， 在这⾥呢，⼀般来说⼯具类我们往往都会设计成为⼀个final类。在JDK中，被设计为final类的有String、 System等。

6.5 final和static

很多时候会容易把static和final关键字混淆，static作⽤于成员变量⽤来表示只保存⼀份副本，⽽final的作⽤是⽤来 保证变量不可变。看下⾯这个例⼦：

class MyClass {
 public final double i = Math.random();
 public static double j = Math.random();
}
public class Test2 {
 public static void main(String[] args) {
 MyClass myClass1 = new MyClass();
 MyClass myClass2 = new MyClass();
 System.out.println(myClass1.i);
 System.out.println(myClass1.j);
 System.out.println(myClass2.i);
 System.out.println(myClass2.j);
 }
}
// 输出：
// 0.6885279073145978
// 0.7678464493258529
// 0.5645174724833194
// 0.7678464493258529

运⾏这段代码就会发现，每次打印的两个j值都是⼀样的，⽽i的值却是不同的。从这⾥就可以知道final和static变量 的区别了。

6.6 final和volatitle

这两个变量看起来没有什么关系，但是我学习JAVA内存模型时，感觉两者还是有很多异同，下⾯我简单总结⼀下。

禁⽌重排序规则：

• 对于volatitle，volatitle变量前⾯的赋值和取值，只能排在volatitle变量的前⾯，volatitle变量后⾯赋值 和取值，只能排在volatitle变量的后⾯，这个雷打不动！⾄于volatitle变量前⾯的赋值和取值，⽐如 a=1，b=2，他们的排序就不能保证了，可能是b=2，a=1，所以只能保证a和b是排在volatitle变量前 ⾯，volatitle变量后⾯的排序规则同上。(volatitle的排序规则，是针对volatitle的前后变量⽽⾔的)
• 对于final，它的禁⽌重排序规则和它前后的变量没有任何关系，可以排在final前，也可以排在final后。 final的禁⽌重排序规则是针对构造函数⽽⾔的，也就是只有先给final赋值或者取值后，才能完成构造函 数的初始化，但是普通变量，可能是先初始化构造函数，然后在给变量赋值。同理，当获取某个对象 时，也是只能先成功获取该对象的引⽤，再去获取final成员变量的值，但是普通变量不能保证，可能会 导致普通变量的读取，排在了获取对象引⽤的前⾯。（final的排序规则，是针对final的成员变量和对象 的构造函数⽽⾔）

内存可⻅性：

• 两者都有相同的内存可⻅性，对于final，这个值都不变，所有的线程看到的值都是⼀样的，当然所有线 程可⻅。对于volatitle，它的值的改变，是强刷内存的，同时也会让其它线程的本地缓存的值也相应改变。

使⽤场景：

• final主要是保证某个值不变，或者不类不被继承。volatitle主要是保证多个线程对该变量的内存可⻅ 性，常⽤于多个线程开始、结束的标记符等。所以说，两者的使⽤场景，简直是⻛⻢⽜不相及。

七、总结

本章详细讲解了final的内存语义和使⽤⽅式，内存语义主要是涉及到并发编程相关的知识，仅供了解即可。其实我 们最终还是需要注重final的使⽤⽅式，分别从变量、⽅法、类，对⻬进⾏讲解，这块知识很简单，主要是做个记 录，最后是final和static，也是⽹上看到的示例，也只做个简单的记录。

这些内容，其实是根据《深⼊理解Java内存模型》，然后结合⽹上的资料，做了相关整理和总结，其实都属于Java 内存模型⽅⾯的内容，通过这4篇⽂章，⼤家对Java内存模型应该会有整体的了解，后⾯才真正讲解并发编程相关的知识。