懒汉式单例模式的问题和Double Check

单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。

该模式有三个基本要点：

• 这个类只能有一个实例；
• 它必须自行创建这个实例；
• 它必须自行向整个系统提供这个实例。

懒汉式单例模式,使用的时候才创建

• 但懒汉式单例在多线程情况下会出现一个问题， 就是在多线程情况下会出现单例对象会创建多个实例；

/**
 * 懒汉式单例模式,使用的时候才创建，
 * 在多线程情况下会出现一个问题，
 * 就是在多线程情况下会出现单例对象会创建多个实例；
 */

class Singleton {
    private static Singleton singleton;

    private Singleton(){}

    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }

        return singleton;
    }
}

解决多线程单例对象会创建多个实例的问题，有多个解决方案：

• 使用锁

class Singleton2 {
    private static Singleton2 singleton2;

    private Singleton2(){}

    /**
     * 多线程情况下，加锁，影响性能
     * @return
     */
    public static synchronized Singleton2 getInstance(){
        if(singleton2 == null){
            singleton2 = new Singleton2();
        }

        return singleton2;
    }
}

• Double Check做法：锁前、锁后检查两次单例对象是否存在

/**
 * double check的做法可以很好的解决多线程情况，
 * 出现单例对象会创建多个实例；
 * 但是，由于CPU和JNI的优化，会出现指令重排序的情况，
 * 导致在多线程情况下，单例对象实例化后的结果为null。
 */
class Singleton3 {
    private static Singleton3 singleton3;

    private Singleton3(){}

    public static Singleton3 getInstance(){
        if(singleton3 == null){
            synchronized (Singleton3.class){
                if(singleton3 == null){
                    singleton3 = new Singleton3();
                }
            }
        }

        return singleton3;
    }
}

• 为了解决Double Check中出现指令重排的问题，我们可以使用volatile关键字，volatile关键字可以使得其修饰的变量实现可见性和有序性，但不能解决原子性。

/**
 * 为了解决double check在多线程情况下的指令重排序的情况，
 * 我们可以使用volatile关键字，可以利用as-if-serial语义来解决该问题。
 */
class Singleton4 {
    private volatile static Singleton4 singleton4;

    private Singleton4(){}

    public static Singleton4 getInstance(){
        if(singleton4 == null){
            synchronized (Singleton4.class){
                if(singleton4 == null){
                    singleton4 = new Singleton4();
                }
            }
        }

        return singleton4;
    }
}

• SingletonHolder解决Double Check的指令重排序问题

/**
 * 为了解决double check在多线程情况下的指令重排序的情况，
 * 外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。
 * 即当SingleTon第一次被加载时，并不需要去加载SingleTonHoler，
 * 只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,
 * 第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类，
 * 这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。
 */
class Singleton5 {
    private static class SingletonHolder{
        public static Singleton5 singleton5 = new Singleton5();
    }

    public static Singleton5 getInstance(){
        return SingletonHolder.singleton5;
    }
}