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

指令重排简述

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

转载于:https://juejin.im/post/5cb9c20e51882529e5627dbd

你可能感兴趣的:(多线程下指令重排与DCL单列模式)