Volatile 原理
volatile 的底层实现原理是内存屏障,Memory Barrier
- 对 volatile 变量的写指令后会加入 写屏障
- 对 volatile 变量的读指令前会加入 读屏障
1. 如何保证可见性
- 写屏障保证在该屏障之前的,对共享变量的改动,都同步到主存当中
public void actor2() {
num = 2;
// volatile 变量
ready = true;
// 写屏障
}
- 而读屏障保证在该屏障之后,对共享变量的读取,加载的是主存中最新数据
public void actor1() {
// 读屏障
if(ready) {
}
}
2. 如何保证有序性
- 写屏障会确保指令重排序时,不会将写屏障之前的代码排在写屏障之后
public void actor2() {
num = 2;
// volatile 变量
ready = true;
// 写屏障
int i = 5; // 不会被重排序到 ready 前面
int j = 3;
}
- 读屏障会确保指令重排序时,不会将读屏障之后的代码排在读屏障之前
public void actor1(int i) {
// 读屏障
if(ready) {
i = 5;
}
}
double-checked locking 问题
public final class Singleton {
private Singleton() {}
// 使用 volatile 可以避免多线程问题
private static Singleton INSTANCE = null;
public static Singleton getInstance () {
if(INSTANCE == null) {
synchronized(Singleton.class) {
if(INSTANCE == null) {
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
}
字节码
0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
6: ldc #3 // class cn/itcast/n5/Singleton
8: dup
9: astore_0
10: monitorenter
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27
17: new #3 // class cn/itcast/n5/Singleton
20: dup
21: invokespecial #4 // Method "<init>":()V
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
27: aload_0
28: monitorexit
29: goto 37
32: astore_1
33: aload_0
34: monitorexit
35: aload_1
36: athrow
37: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
40: areturn
也许 jvm 会优化为 先执行 24, 再执行21。在多线程环境下,就会出现获取到一个未初始化完毕的单例。(volatile 底层是 通过 插入 一条 lock 指令实现)
final 原理
设置 final 变量的原理
理解了 volatile 原理,再对比 final 的实现就比较简单了
public class TestFinal {
final int a = 20;
}
0 aload_0
1 invokespecial #1 <java/lang/Object.<init>>
4 aload_0
5 bipush 20
7 putfield #2 <mythread/finaldoc/TestFinal.a>
// 内存屏障
10 return