public class Hungry {
    // 創(chuàng)建唯一實(shí)例
    private final static Hungry HUNGRY = new Hungry();
    private Hungry(){}
	// 全局訪問(wèn)點(diǎn) ---> 拿到HUNGRY實(shí)例
    public static Hungry getIntance(){
        return HUNGRY;
    }
}

public class LazyMan {
    private LazyMan(){}
    public static LazyMan lazyMan;
    public static LazyMan getInstance(){
        if (lazyMan==null){
           lazyMan = new LazyMan();
        }
        return lazyMan;
    }
}

public class LazyMan {
    private LazyMan(){}
    // 懶漢當(dāng)中的雙重檢驗(yàn)鎖 --> 可以保證線程安全
    public volatile static LazyMan lazyMan;
    // volatile 保證了new實(shí)例時(shí)不會(huì)發(fā)生指令重排
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                // 此處上鎖  以保證原子操作
                if (lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
}

public class LazyMan {
    // 空參構(gòu)造器
    private LazyMan(){}
    // 懶漢當(dāng)中的雙重檢驗(yàn)鎖 --> 可以保證線程安全
    public volatile static LazyMan lazyMan;
    // volatile 保證了new實(shí)例時(shí)不會(huì)發(fā)生指令重排
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                // 此處上鎖  以保證原子操作
                if (lazyMan == null){
                    lazyMan = new LazyMan();// 不是原子操作
                }
            }
        }
        return lazyMan;
    }
    public static void main(String[] args) throws Exception{
        // 獲取無(wú)參構(gòu)造器
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);// 無(wú)視私有
        // 獲取實(shí)例
        LazyMan instance2 = constructor.newInstance();
        LazyMan instance3 = constructor.newInstance();
        LazyMan instance4 = constructor.newInstance();
        // 懶漢式單例 獲取唯一實(shí)例
        LazyMan instance = LazyMan.getInstance();
        System.out.println("getIntance獲取實(shí)例(1)hashCode："+instance.hashCode());
        System.out.println("反射構(gòu)造器newIntance獲取實(shí)例(2)hashCode："+instance2.hashCode());
        System.out.println("反射構(gòu)造器newIntance獲取實(shí)例(3)hashCode："+instance3.hashCode());
        System.out.println("反射構(gòu)造器newIntance獲取實(shí)例(4)hashCode："+instance4.hashCode());
    }
}

// 對(duì)空參構(gòu)造器進(jìn)行上鎖 并對(duì)唯一實(shí)例lazyman判斷是否已經(jīng)初始化
 private LazyMan(){
    if (lazyMan != null){
		throw new RuntimeException("不要試圖破壞單例模式");
    }
 }

// 解決2.  對(duì)空參構(gòu)造器進(jìn)行上鎖  利用標(biāo)志位保證空參構(gòu)造器只能初始化一次實(shí)例  但是標(biāo)志位字段仍可以通過(guò)其他途徑被拿到  并且修改
    private static boolean flag = false;
	private LazyMan(){
        synchronized(LazyMan.class){
            if (flag == false){
                flag = true;
            }else {
                throw new RuntimeException("不要試圖破壞單例模式");
            }
        }
    }

public static void main(String[] args) throws Exception{
        // 獲取無(wú)參構(gòu)造器
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);// 無(wú)視私有
        // 懶漢式單例 獲取唯一實(shí)例
        LazyMan instance = LazyMan.getInstance();  // (1)
        // 獲取標(biāo)志位字段并進(jìn)行修改
        Field flag1 = LazyMan.class.getDeclaredField("flag");
        // (1) 處已經(jīng)調(diào)用了空參構(gòu)造器  flag變?yōu)閠rue  此處修改為false 可以繼續(xù)創(chuàng)建實(shí)例
        flag1.set(instance,false);
        LazyMan instance2 = constructor.newInstance();
        // 與上述同理
        flag1.set(instance2,false);
        LazyMan instance3 = constructor.newInstance();
        System.out.println("getIntance獲取實(shí)例(1)hashCode："+instance.hashCode());
        System.out.println("反射構(gòu)造器newIntance獲取實(shí)例(2)hashCode："+instance2.hashCode());
        System.out.println("反射構(gòu)造器newIntance獲取實(shí)例(3)hashCode："+instance3.hashCode());
    }

// 我們只看如下兩行
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");

public enum enumSingle {
    INSTANCE;
    public enumSingle getInstance() {
        return INSTANCE;
    }
}
class TestEnumSingle{
    public static void main(String[] args) throws Exception {
        // 下面我們嘗試用反射來(lái)破壞枚舉類(lèi)
        // 枚舉類(lèi)的構(gòu)造器實(shí)際上帶有兩個(gè)參數(shù) String和int
        Constructor<enumSingle> declaredConstructor = enumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        // 直接獲取實(shí)例
        enumSingle instance = enumSingle.INSTANCE;
        // 反射獲取實(shí)例
        enumSingle enumSingle1 = declaredConstructor.newInstance();
        System.out.println("類(lèi)名直接訪問(wèn)獲取實(shí)例hashCode："+instance.hashCode());
        System.out.println("反射實(shí)例hashCode："+enumSingle1.hashCode());
    }
}
// 最終拋出  java.lang.IllegalArgumentException: Cannot reflectively create enum objects