一、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()⽅法包含三个操作:
- 初次读引⽤变量obj;
- 初次读引⽤变量obj指向对象的普通域j。
- 初次读引⽤变量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内存模型应该会有整体的了解,后⾯才真正讲解并发编程相关的知识。