单例模式DCL

DCL(DOUBLE CHECK LOCK):双端检锁机制

• 单线程环境下：

public class SingletonDemo {
    private static SingletonDemo instance=null;
    //正常情况，只new一份，就只打印一次
    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t 我是构造方法 SingletonDemo()");
    }
    public static SingletonDemo getInstance(){
        if (instance==null)
        {     
           instance=new SingletonDemo();
        }
        return instance;
    }
    public static void main(String[] args) {
        //单线程(main线程的操作动作)
        System.out.println(SingletonDemo.getInstance()==SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance()==SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance()==SingletonDemo.getInstance());
    }
}
运行结果:
main	 我是构造方法 SingletonDemo()
true
true
true

• 多线程环境下：并发多线程后，情况会发生变化

public class SingletonDemo {
    private static SingletonDemo instance=null;
    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t 我是构造方法 SingletonDemo()");
    }

    //1.public static synchronized SingletonDemo getInstance() 尽量不用
    public static SingletonDemo getInstance(){
        if (instance==null)
        {
           instance=new SingletonDemo();
        }
        return instance;
    }
    public static void main(String[] args) {
      //并发多线程后，情况发生变化
       for (int i=1;i<=10;i++){
            new Thread(()->{
                SingletonDemo.getInstance();
            },String.valueOf(i)).start();
        }
    }
}

运行结果:
1	 我是构造方法 SingletonDemo()
3	 我是构造方法 SingletonDemo()
2	 我是构造方法 SingletonDemo()

• 引出DCL(双端检锁机制)：

public class SingletonDemo {
    private static SingletonDemo instance=null;
    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t 我是构造方法 SingletonDemo()");
    }

    //1.public static synchronized SingletonDemo getInstance() 尽量不用
    //2.DCL(DOUBLE CHECK LOCK 双端检锁机制)
    public static SingletonDemo getInstance(){
        if (instance==null)
        {
           synchronized (SingletonDemo.class){
                if (instance==null){
                    //只需要控制这一行，就没问题了
                    instance=new SingletonDemo();
                }
            }
        }
        return instance;
    }
    public static void main(String[] args) {
       //并发多线程后，情况发生变化
       for (int i=1;i<=10;i++){
            new Thread(()->{
                SingletonDemo.getInstance();
            },String.valueOf(i)).start();
        }
    }
}
运行结果:
1	 我是构造方法 SingletonDemo()

上面代码结果看似没有问题，实际上由于多线程环境下，为了高性能，底层会有指令重排，如果未控制好，实际上还是有问题出现

因此双端检锁机制不一定线程安全，只有加上volatile禁止指令重排，这个程序才是完美的

原因在于某一个线程执行到第一次检测，读取到instance不为null时，instance的引用对象可能没有完成初始化

instance=new SingletonDemo()；正常情况可以分为以下三步骤：

• 1.分配对象内存
• 2.初始化对象
• 3.设置instance指向刚分配的内存地址，此时instance!=null
• 实际上步骤2,3不存在数据依赖关系，无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的 
• 假如2,3对换 ，所以当一条线程访问instance不为null时，由于instance实例未必初始化完成，也就造成了线程安全问题

指令重排只会保证串行语义的执行的一致性(单线程)，但不会关心多线程之间语义的一致性。

• 修改： private static volatile SingletonDemo instance=null;

public class SingletonDemo {
//加上volatile关键字修饰
    private static volatile SingletonDemo instance=null;
    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t 我是构造方法 SingletonDemo()");
    }

    //1.public static synchronized SingletonDemo getInstance() 尽量不用
    //2.DCL(DOUBLE CHECK LOCK 双端检锁机制)
    public static SingletonDemo getInstance(){
        if (instance==null)
        {
           synchronized (SingletonDemo.class){
                if (instance==null){
                    //只需要控制这一行，就没问题了
                    instance=new SingletonDemo();
                }
            }
        }
        return instance;
    }
    public static void main(String[] args) {

      //并发多线程后，情况发生变化
       for (int i=1;i<=10;i++){
            new Thread(()->{
                SingletonDemo.getInstance();
            },String.valueOf(i)).start();
        }
    }
}
运行结果：
1	 我是构造方法 SingletonDemo()