指令重排简述
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;
