不会单例模式的程序员不是一个合格的程序员

饿汉式

public class SingletonPattern01 {

    private static SingletonPattern01 singletonPattern01 = new SingletonPattern01();

    private SingletonPattern01(){

    }

    public static SingletonPattern01 getInstance(){
        return singletonPattern01;
    }

}

懒汉式第一版

public class SingletonPattern02 {

    /**
     * 定义一个带对象为成员变量
     */
    private static volatile SingletonPattern02 singletonPattern02;

    /**
     * 构造方法私有化
     */
    private SingletonPattern02(){

    }

    /**
     * 双重锁判断
     * @return 该类对象
     */
    public static SingletonPattern02 getInstance(){
        if (singletonPattern02 != null){
            synchronized (SingletonPattern02.class){
                if (singletonPattern02 != null){
                    singletonPattern02 = new SingletonPattern02();
                }
            }
        }
        return singletonPattern02;
    }
}

懒汉式第二版

/**
 * 懒汉式的情况下 还会出现通过反射破坏单例的情况 我们先通过调用getInstance()方法创建对象后，再通过反射直接执行私有的构造方法，这样就破坏了单例
 * 所以在私有的构造方法中进行一个if判断
 * @author hs
 * @date 2021/06/23
 */
public class SingletonPattern03 {

    /**
     * 定义一个带对象为成员变量
     */
    private static volatile SingletonPattern03 singletonPattern03;

    /**
     * 构造方法私有化，就是在这里加一个判断，因为反射只是指向私有的构造方法，
     */
    private SingletonPattern03(){
        if (singletonPattern03 != null){
            throw new RuntimeException("请不要使用反射创建对象");
        }
    }

    /**
     * 双重锁判断
     * @return 该类对象
     */
    public static SingletonPattern03 getInstance(){
        if (singletonPattern03 != null){
            synchronized (SingletonPattern03.class){
                if (singletonPattern03 != null){
                    singletonPattern03 = new SingletonPattern03();
                }
            }
        }
        return singletonPattern03;
    }

}

懒汉式第三版

/**
 * 上方版本还是有可能会出现破坏单例的情况，如果我没有执行getInstance()方法，而是直接通过反射执行两次私有的构造方法
 * 解决方案是 自己定义一个成员变量做判断 在私有构造方法中再加判断
 * @author hs
 * @date 2021/06/23
 */
public class SingletonPattern04 {

    /**
     * 定义一个带对象为成员变量
     */
    private static volatile SingletonPattern04 singletonPattern04;

    /**
     * 定义一个只有自己知道的成员变量
     */
    private static boolean hs = false;



    /**
     * 构造方法私有化，就是在这里加一个判断，因为反射只是指向私有的构造方法，
     */
    private SingletonPattern04(){
        if (hs){
            throw new RuntimeException("请不要使用反射创建对象");
        }else {
            hs = true;
        }
    }

    /**
     * 双重锁判断
     * @return 该类对象
     */
    public static SingletonPattern04 getInstance(){
        if (singletonPattern04 != null){
            synchronized (SingletonPattern04.class){
                if (singletonPattern04 != null){
                    singletonPattern04 = new SingletonPattern04();
                }
            }
        }
        return singletonPattern04;
    }

}