23種設計模式之單例模式（8種寫法）

``23種設計模式之單例模式（8種寫法）

/**
 * 餓漢式
 * <p>
 * 高效 沒有執行緒安全問題  簡單
 * <p>
 * jvm保證執行緒安全問題
 */
public class Merge01 {
    private static final Merge01 test = new Merge01();

    private Merge01() {
    }

    public static Merge01 getInstance() {
        return test;
    }

    public static void main(String[] args) {
        Merge01 test001 = Merge01.getInstance();
        Merge01 test002 = Merge01.getInstance();

        System.out.println(test002 == test002);
    }
}

/**
 * 用靜態塊初始化
 */
public class Merge02 {
    private static final Merge02 INSTANCE;

    static {
        INSTANCE = new Merge02();
    }


    private Merge02() {
    }

    ;

    public static Merge02 getInstance() {
        return INSTANCE;
    }

    ;

    public static void main(String[] args) {
        Merge02 test001 = Merge02.getInstance();
        Merge02 test002 = Merge02.getInstance();

        System.out.println(test002 == test002);
    }
}

/**
 * 懶漢式
 * 懶加載模式  lazy-loading
 * 做到了按需初始化，但是多執行緒訪問時有執行緒安全問題
 */
public class Merge03 {
    private static Merge03 INSTANCE;

    private Merge03() {
    }

    ;

    public static Merge03 getInstance() {

        if (INSTANCE == null) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            }
            INSTANCE = new Merge03();

        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Merge03.getInstance().hashCode());
            }).start();
        }
    }

}


/**
 * 懶加載模式  lazy-loading  加鎖避免了執行緒安全問題，但是效率受影響
 */
public class Merge04 {
    private static Merge04 INSTANCE;

    private Merge04() {
    }

    ;

    public static synchronized Merge04 getInstance() {

        if (INSTANCE == null) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            }
            INSTANCE = new Merge04();

        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Merge04.getInstance().hashCode());
            }).start();
        }
    }

}


/**
 * 懶加載模式  lazy-loading
 * instance == null 和sychnorized方法沒有同步，執行緒安全問題存在、
 */
public class Merge05 {
    private static Merge05 INSTANCE;

    private Merge05() {
    }

    ;

    public static Merge05 getInstance() {

        if (INSTANCE == null) {
            synchronized (Merge05.class) {
                try {
                    Thread.sleep(10);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                INSTANCE = new Merge05();
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Merge05.getInstance().hashCode());
            }).start();
        }
    }

}


/**
 * 懶加載模式  lazy-loading
 * 雙重檢查，接近完美
 */
public class Merge06 {
    private static
    Merge06 INSTANCE;

    private Merge06() {
    }

    ;

    public static Merge06 getInstance() {

        if (INSTANCE == null) {
            synchronized (Merge06.class) {
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Merge06();
                }

            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Merge06.getInstance().hashCode());
            }).start();
        }
    }

}


/**
 * 懶加載模式  lazy-loading
 * <p>
 * 靜態內部類方式，jvm保證執行緒安全問題，
 * <p>
 * Merge07Holder在呼叫getInstance()時才被實體一次，所以INSTANCE實體也只被實體一次，幾乎完美的方式
 */
public class Merge07 {
    private Merge07() {
    }

    ;

    private static class Merge07Holder {
        private static final Merge07 INSTANCE = new Merge07();
    }

    public static Merge07 getInstance() {
        return Merge07Holder.INSTANCE;
    }


    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Merge07.getInstance().hashCode());
            }).start();
        }
    }

}


/**
 * 列舉類寫法
 * 解決執行緒安全問題，同時方式反序列化
 */
public enum Merge08 {
    INSTANCE;

    public void m() {

    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Merge08.INSTANCE.hashCode());
            }).start();
        }
    }
}