/**
 * @Auther: csp1999
 * @Date: 2020/11/06/20:36
 * @Description: 單例設計模式-懶漢式
 */
public class SingletonLazy {
    // 當需要用到該實例的時候再創(chuàng)建實例對象
    private static SingletonLazy instance;
    /**
     * 構造函數(shù)私有化
     * 不能通過 new SingletonLazy() 的方式創(chuàng)建實例
     * 
     * 當需要用到該實例的時候在加載
     * 只能通過 SingletonLazy.getInstance() 這種方式獲取實例
     */
    private SingletonLazy() {
    }
    /**
     * 單例對象的方法
     */
    public void process() {
        System.out.println("方法實例化成功！");
    }
    /**
     * 方式一：
     * <p>
     * 對外暴露一個方法獲取該類的對象
     * <p>
     * 缺點：線程不安全，多線程下存在安全問題
     *
     * @return
     */
    public static SingletonLazy getInstance() {
        if (instance == null) {// 實例為null時候才創(chuàng)建
            /**
             * 線程安全問題：
             * 當某一時刻，兩個或多個線程同時判斷到instance == null成立的時候
             * 這些線程同時進入該if判斷內部執(zhí)行實例化
             * 則會新建出不止一個SingletonLazy實例
             */
            instance = new SingletonLazy();// 當需要的時候再進行實例化對象
        }
        return instance;
    }
    /**
     * 方式二：
     * 通過加synchronized鎖 保證線程安全
     *
     * 采用synchronized 對方法加鎖有很大的性能開銷
     * 因為當getInstance2()內部邏輯比較復雜的時候，在高并發(fā)條件下
     * 沒獲取到加鎖方法執(zhí)行權的線程，都得等到這個方法內的復雜邏輯執(zhí)行完后才能執(zhí)行，等待浪費時間，效率比較低
     *
     * @return
     */
    public static synchronized SingletonLazy getInstance2() {
        if (instance == null) {// 實例為null時候才創(chuàng)建
            // 方法上加synchronized鎖后可以保證線程安全
            instance = new SingletonLazy();// 當需要的時候再進行實例化對象
        }
        return instance;
    }
    /**
     * 方式三：
     * 在getInstance3()方法內，針對局部需要加鎖的代碼塊加鎖，而不是給整個方法加鎖
     *
     * 也存在缺陷：
     * @return
     */
    public static SingletonLazy getInstance3() {
        if (instance == null) {// 實例為null時候才創(chuàng)建
            // 局部加鎖后可以保證線程安全,效率較高
            // 缺陷：假設線程A和線程B
            synchronized (SingletonLazy.class){
                // 當線程A獲得鎖的執(zhí)行權的時候B等待 A執(zhí)行new SingletonLazy();實例化
                // 當A線程執(zhí)行完畢后，B再獲得執(zhí)行權，這時候還是可以實例化該對象
                instance = new SingletonLazy();// 當需要的時候再進行實例化對象
            }
        }
        return instance;
    }
}

/**
 * 方式三改進版本：
 * 在getInstance3()方法內，針對局部需要加鎖的代碼塊加鎖，而不是給整個方法加鎖
 *
 * DCL 雙重檢查鎖定 (Double-Checked-Locking) 在多線程情況下保持高性能
 *
 * 這是否安全？ instance = new SingletonLazy(); 并不是原子性操作
 * jvm中 instance實例化內存模型流程如下：
 * 1.分配空間給對象
 * 2.在空間內創(chuàng)建對象
 * 3.將對象賦值給instance引用
 *
 * 假如出現(xiàn)如下順序錯亂的情況：
 * 線程的執(zhí)行順序為：1 -> 3 -> 2, 那么這時候會把值寫回主內存
 * 則，其他線程就會讀取到instance的最新值,但是這個是不完全的對象
 * (指令重排現(xiàn)象)
 *
 * @return
 */
public static SingletonLazy getInstance3plus() {
    if (instance == null) {// 實例為null時候才創(chuàng)建
        // 局部加鎖后可以保證線程安全,效率較高
        // 假設線程A和線程B 
        synchronized (SingletonLazy.class){// 第一重檢查
            // 當線程A獲得鎖的執(zhí)行權的時候B等待 A執(zhí)行new SingletonLazy();實例化
            // 當A線程執(zhí)行完畢后，B再獲得執(zhí)行權，這時候再判斷instance == null是否成立
            // 如果不成立，B線程無法 實例化SingletonLazy
            if (instance == null){// 第二重檢查
                instance = new SingletonLazy();// 當需要的時候再進行實例化對象
            }
        }
    }
    return instance;
}

// 添加volatile 關鍵字，禁止實例化對象時，內存模型中出現(xiàn)指令重排現(xiàn)象
private static volatile SingletonLazy instance;
/**
 * 方式三再次升級版本：
 * 在getInstance3()方法內，針對局部需要加鎖的代碼塊加鎖，而不是給整個方法加鎖
 *
 * DCL 雙重檢查鎖定 (Double-Checked-Locking) 在多線程情況下保持高性能
 *
 * 解決指令重排問題——禁止指令重排
 * @return
 */
public static SingletonLazy getInstance3plusplus() {
    if (instance == null) {// 實例為null時候才創(chuàng)建
        // 局部加鎖后可以保證線程安全,效率較高
        // 假設線程A和線程B
        synchronized (SingletonLazy.class){// 第一重檢查
            // 當線程A獲得鎖的執(zhí)行權的時候B等待 A執(zhí)行new SingletonLazy();實例化
            // 當A線程執(zhí)行完畢后，B再獲得執(zhí)行權，這時候再判斷instance == null是否成立
            // 如果不成立，B線程無法 實例化SingletonLazy
            if (instance == null){// 第二重檢查
                instance = new SingletonLazy();// 當需要的時候再進行實例化對象
            }
        }
    }
    return instance;
}

@Test
public void testSingletonLazy(){
    SingletonLazy.getInstance().process();
}

/**
 * @Auther: csp1999
 * @Date: 2020/11/06/21:39
 * @Description: 單例設計模式-餓漢式
 */
public class SingletonHungry {
    // 當類加載的時候就直接實例化對象
    private static SingletonHungry instance = new SingletonHungry();
    private SingletonHungry(){}
    /**
     * 單例對象的方法
     */
    public void process() {
        System.out.println("方法實例化成功！");
    }
    public static SingletonHungry getInstance(){
        return instance;// 當類加載的時候就直接實例化對象
    }
}

@Test
public void testSingletonHungry(){
    SingletonHungry.getInstance().process();
}