Volatile 原理

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