单例模式--＞饿汉式+懒汉式

单例模式：要求整个程序只有一个对象
 *   三步骤：1.私有化构造方法
 *          2.在类的内部创建一个对象
 *          3.通过公开的方法，返回这个对象

/*
 *饿汉式：类一加载，对象就初始化
 *          缺点：生命周期太长，浪费空间
 *          优点：线程安全
 * /
public class SingleTon2 {
    //私有化构造方法
    private SingleTon2(){};
    //私有化对象
    private static SingleTon2 instance = null;
    //公开方法返回对象
    public static synchronized SingleTon2 getInstance(){
        if(instance == null){
            instance = new SingleTon2();
        }
        return instance;
    }
}

public class SingleTon {
    //1.私有构造方法
    private SingleTon(){}
    //2.在类的内部创建一个对象
    private static SingleTon instance;
    //    3.通过公开的方法，返回这个对象
    public static SingleTon getInstance(){
        if(instance==null){
            instance = new SingleTon();
        }
        return instance;
    }


}

/*
好处：生命周期短，节省空间 缺点：线程不安全，必须使用同步解决
 */
  
public class SingleTon2 {
    //(1)私有化构造方法
    private static boolean flag=false;
    private SingleTon2(){
        if(flag){
            throw new RuntimeException("不能反射破解");
        }
    }
    //(2)在类内部创建一个对象
    private static volatile SingleTon2 instance;
    //(3)通过公开的方法，返回这个对象
    public static  SingleTon2 getInstance(){
        //判断锁是否可用效率低
        if(instance==null) {//目的：提高效率, double check双重检查
            synchronized (SingleTon2.class) {
                if (instance == null) {
                    //(1)new  (2)dup  (3)invokespecial  (4)astore
                    // 1 2 3 4
                    // 1 2 4 3  多线程问题?
                    instance = new SingleTon2();
                    flag=true;
                }
            }
        }
        return instance;
    }
}