多线程下指令重排与DCL单列模式

1、JMM内存模型三大特性包括原子性，可见性，有序性。详细请看https://juejin.im/post/5cb5d419e51d456e500f7d02。

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;
复制代码