面试：DCL单例需不需要加volatile关键字？

首先，讲一下什么是单例模式？

单例模式，简单理解就是在程序运行期间有且只有一个实例对外访问。

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

最简单的单例模式为：

/**
 * @author yangpengfei
 * @description 这就是单例模式中的饿汉式代码案例
 */
public class Test01 {

    private static Test01 INSTANCE =  new Test01(); // 建立一个静态类实例对象，供外部访问

    private Test01 () {}  // 私有化构造方法，防止被外部对象实例化

    public static Test01 getInstance(){ // 对外提供唯一获取本类实例方法
        return INSTANCE;  // 返回最终结果
    }

}

这时候，有人会说，你这直接初始化对象，我想在使用的时候在创建对象，也就是我们的懒汉式案例

/**
 * @author yangpengfei
 * @description 这就是单例模式中的懒汉式案例
 */
public class Test01 {

    private static Test01 INSTANCE = null; // 建立一个静态类实例对象，供外部访问

    private Test01 () {}  // 私有化构造方法，防止被外部对象实例化

    public static Test01 getInstance(){ // 对外提供唯一获取本类实例方法
        if(INSTANCE == null){
            INSTANCE = new Test01();
        }
        return INSTANCE;  // 返回最终结果
    }

}

懒汉式在多线程环境中不能保证实例的唯一性，这时候会想到用锁机制啊，加一个 synchronized 关键字就可以了，如下所示：

/**
 * @author yangpengfei
 * @description 这就是单例模式中的synchronized 加锁的懒汉式案例
 */
public class Test01 {

    private static Test01 INSTANCE = null; // 建立一个静态类实例对象，供外部访问

    private Test01 () {}  // 私有化构造方法，防止被外部对象实例化

    public static synchronized Test01 getInstance(){ // 对外提供唯一获取本类实例方法
        if(INSTANCE == null){
            INSTANCE = new Test01();
        }
        return INSTANCE;  // 返回最终结果
    }

}

这样加锁的话，在多线程的情况下，锁太粗粒度化了，影响代码的性能，于是有了如下的代码：

/**
 * @author yangpengfei
 * @description 这就是单例模式中的synchronized 加锁的懒汉式案例
 */
public class Test01 {

    private static Test01 INSTANCE = null; // 建立一个静态类实例对象，供外部访问

    private Test01 () {}  // 私有化构造方法，防止被外部对象实例化

    public static Test01 getInstance(){ // 对外提供唯一获取本类实例方法
        if(INSTANCE == null){
            synchronized(Test01.class) {
                INSTANCE = new Test01();
            }
        }
        return INSTANCE;  // 返回最终结果
    }

}

这样就实现了锁对象的细粒度化，但是有个问题，还是不能保证实例的唯一性，所以就加入了双重检查的方式，即DCL模式单例

DCL单例

指的是 Double check Lock,双重检查对象是否初始化；

/**
 * @author yangpengfei
 * @description DCL单例案例
 */
public class Test01 {

    private static Test01 INSTANCE = null; // 建立一个静态类实例对象，供外部访问

    private Test01 () {}  // 私有化构造方法，防止被外部对象实例化

    public static Test01 getInstance(){ // 对外提供唯一获取本类实例方法
        if(INSTANCE == null){
            synchronized(Test01.class) {   // 多线程进来时，同时竞争锁对象时，每个线程本地对象都是 null ,所以 多线程情况下，不是单例模式
                if(INSTANCE == null){  // Double check lock ，双重检查对象是否初始化成功
                    INSTANCE == new Test01();
                }
            }
        }
        return INSTANCE;  // 返回最终结果
    }

}

这种情况下，每个线程在获取到锁对象时，因为每个线程内部的INSTANCE对象都是null,所以还是不能保证实例的唯一性；这时候应该能想到使用volatile关键字，因为这个关键字是保证了不同线程对该变量操作的内存可见性，禁止指令重排序。所以，当DCL检查时，会从主存里面获取最新的状态数据

volatile关键字修饰的变量， 在class字节码中只是添加了volatile；

volatile 利用了内存屏障，处于屏障两边的不能被指令重排序

/**
 * @author yangpengfei
 * @description DCL单例案例 + volatile 关键字
 */
public class Test01 {

    private static volatile Test01 INSTANCE = null; // 建立一个静态类实例对象，供外部访问

    private Test01 () {}  // 私有化构造方法，防止被外部对象实例化

    public static Test01 getInstance(){ // 对外提供唯一获取本类实例方法
        if(INSTANCE == null){
            synchronized(Test01.class) {   // 多线程进来时，同时竞争锁对象时，每个线程本地对象都是 null ,所以 多线程情况下，不是单例模式
                if(INSTANCE == null){  // Double check lock ，双重检查对象是否初始化成功
                    INSTANCE == new Test01();
                }
            }
        }
        return INSTANCE;  // 返回最终结果
    }

}

还有两种，一种是静态内部类，一种是枚举类；

/**
 * 静态内部类加载机制，这种方式通过jvm来保证其线程安全，而懒加载的机制则是依靠虚拟机规范制度的类“初始化”规则保证
 */
public class Test01 {
    private static class Test01Holder {
        private static final Test01  singleton = new Test01 ();
    }

    private Test01 () {
    }

    public static Test01 getInstance() {
        return Test01Holder .singleton;
    }
}

枚举类:利用枚举的特性，让JVM来帮我们保证线程安全和单一实例的问题

public enum Test01 {
    INSTANCE;
    public void hello(){
        System.out.println("hello");
    }
}