指令重排简述
1、JMM内存模型三大特性包括原子性,可见性,有序性。详细请看关于Java内存模型的三大特性
2、指令重排是相对有序性来说的,指在程序执行过程中, 为了性能考虑, 编译器和CPU可能会对指令重新排序。单线程模式下只有一个执行引擎,不存在竞争,所有的操作都是有有序的,不影响最后的执行结果。
3、指令重排只能保证串行(单线程)语句执行的一致性。
单例模式
假设我的单列对象是Faith(一个人只有一个信仰),查看多线程下示例的创建次数,即构造函数的调用次数。
饿汉模式
示例代码
class Faith {
private static Faith myFaith = new Faith();
private Faith(){
System.out.println("Faith.Faith --- 私有构造调用了");
}
public static Faith getMyFaith() {
return myFaith;
}
}
public class TestSingleton {
public static void main(String[] args) {
for (int i = 0; i <= 10; i++) {
new Thread(() -> {
Faith.getMyFaith();
},String.valueOf(i)).start();
}
}
}
复制代码
控制台:
Faith.Faith --- 私有构造调用了
复制代码
- 多条线程同时运行时,只创建了一个实例。
- 饿汉模式下,在类加载的时候创建一次实例,不会存在多个线程创建多个实例的情况。但在类加载时就自动创建,占用内存。
- 因此重点讲懒汉模式,即第一次调用获取实列方法时,才被动创建对象。
懒汉模式
单线程懒汉模式
示例代码
class Faith {
private static Faith myFaith = null;
private Faith(){
System.out.println(Thread.currentThread().getName()+" --- Faith.Faith --- 私有构造调用了");
}
public static Faith getMyFaith() {
if (myFaith == null){
myFaith = new Faith();
}
return myFaith;
}
}
复制代码
上面的代码是单线程下的懒汉模式,但是在并发情况下,当myFaith为空,需new对象时,多个线程可能同时进入这个方法。
public class TestSingleton {
public static void main(String[] args) {
for (int i = 0; i <= 10; i++) {
new Thread(() -> {
Faith.getMyFaith();
},String.valueOf(i)).start();
}
}
}
复制代码
控制台:
5 --- Faith.Faith --- 私有构造调用了
1 --- Faith.Faith --- 私有构造调用了
8 --- Faith.Faith --- 私有构造调用了
4 --- Faith.Faith --- 私有构造调用了
2 --- Faith.Faith --- 私有构造调用了
3 --- Faith.Faith --- 私有构造调用了
9 --- Faith.Faith --- 私有构造调用了
7 --- Faith.Faith --- 私有构造调用了
10 --- Faith.Faith --- 私有构造调用了
0 --- Faith.Faith --- 私有构造调用了
6 --- Faith.Faith --- 私有构造调用了
复制代码
可以看到,结果非常糟糕,得到多个不同对象。
多线程懒汉模式-synchronized
最直接的方法就是在静态方法上加synchronized
互斥锁.
public static synchronized Faith getMyFaith() {
if (myFaith == null){
myFaith = new Faith();
}
return myFaith;
}
复制代码
synchronized属于重量锁,在高并发情况下,上百条个线程都等在静态方法外,阻塞很大,不推荐。
多线程懒汉模式-DCL
DCL(double check lock)双端检索机制,在new方法上加同步锁,但要在加锁前后进行非空判断。
class Faith {
private static Faith myFaith = null;
private Faith(){
System.out.println(Thread.currentThread().getName()+" --- Faith.Faith --- 私有构造调用了");
}
public static Faith getMyFaith() {
// 第一次判断,若myFaith实例为空
if (myFaith == null){
// 加同步锁
synchronized (Faith.class) {
// 第二次判断,若myFaith实例确实为空,进入构造方法
if (myFaith == null) {
myFaith = new Faith();
}
}
}
return myFaith;
}
}
复制代码
public class TestSingleton {
public static void main(String[] args) {
for (int i = 0; i <= 10; i++) {
new Thread(() -> {
Faith.getMyFaith();
},String.valueOf(i)).start();
}
}
}
复制代码
控制台:
0 --- Faith.Faith --- 私有构造调用了
复制代码
- 可以看到,10条线程下,只获取到一个实列对象,看似是一个相对高效的方法。但在本文一开始,就提到了指令重排。
- 当myFaith为空,进入初始化,当还没初始化完成时,会有线程安全问题。
指令重排分析
myFaith = new Faith();,该方法其实有3步:
1、分配内存空间何内存地址
memeory = allocate;
复制代码
2、初始化对象
myFaith(memory);
复制代码
3、将实例指向分配的内存地址
myFaith = memory;
复制代码
第二步和第三步没有数据依赖关系,单线程下指令重排不影响执行结果,因此编译器和cpu允许重排优化的行为。
即可能出现第三步先于第二部执行, myFaith = memory; 此时因为已经给即将创建的myFaith分配了内存空间,所以myFaith!=null,但对象的初始化还没有完成,造成线程安全问题。
多线程懒汉模式-DCL+volatile
JMM保证有序性的重要方法就是引入J.U.C并发包下的volatile
关键字,volatile 关键字通过添加内存屏障的方式来禁止指令重排,即重排序时不能把后面的指令放到内存屏障之前。
即原来的DCL单例模式,在实例对象上再加volatile修饰即可。
private static volatile Faith myFaith = null;
复制代码