懒汉式单例模式的问题和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(){}

    
    public static synchronized Singleton2 getInstance(){
        if(singleton2 == null){
            singleton2 = new Singleton2();
        }

        return singleton2;
    }
}

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

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关键字可以使得其修饰的变量实现可见性和有序性，但不能解决原子性。

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的指令重排序问题

class Singleton5 {
    private static class SingletonHolder{
        public static Singleton5 singleton5 = new Singleton5();
    }

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