實現單例的幾種方式

餓漢模式：

餓漢模式在類被初始化時就已經在內存中創建了對象,以空間換時間，故不存在線程安全問題。

package com.phy.java.singleton;

/**
 * @author ：mmzs
 * @date ：Created in 2020/4/12 12:11
 * @description：武漢模式不存在線程安全
 * @modified By：
 * @version: $
 */
public class HungrySingleton {
    // 立即加載方式==餓漢模式(空間換時間)
    private static HungrySingleton singleton = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        // 此代碼版本爲立即加載
        // 此版本代碼的缺點是不能有其它實例變量
        // 因爲getInstance()方法沒有同步
        // 所以有可能出現非線程安全問題
        return singleton;
    }
}

懶漢模式：

懶漢模式在方法被調用後才創建對象，以時間換空間，在多線程環境下存在風險。

package com.phy.java.singleton;

/**
 * @author ：mmzs
 * @date ：Created in 2020/4/12 11:51
 * @description：非線程安全的實現單例
 * @modified By：
 * @version: $
 */
public class NoSafetyLazySingleton {
    private static NoSafetyLazySingleton singleton;

    public NoSafetyLazySingleton() {
    }
    //getInstance()的返回值是一個對象的引用，並不是一個新的實例
    public static NoSafetyLazySingleton getInstance() {
        if (singleton == null) {
            singleton = new NoSafetyLazySingleton();
        }
        return singleton;
    }
}

package com.phy.java.singleton;

/**
 * @author ：mmzs
 * @date ：Created in 2020/4/12 11:57
 * @description：線程安全實現單例利用synchronized關鍵字，缺點是效率低
 * @modified By：
 * @version: $
 */
public class SafetyLazySingletonByKey {
    private static SafetyLazySingletonByKey instance;
    private SafetyLazySingletonByKey(){}
    //餓漢式利用synchronized 關鍵字實現單例模式
    public static synchronized SafetyLazySingletonByKey getInstance() {
        if (instance == null) {
            //懶加載模式（懶漢式）用的時候在加載
            instance = new SafetyLazySingletonByKey();
        }
        return instance;
    }
}

雙重鎖懶漢模式：

只有在對象需要被使用時才創建，第一次判斷 INSTANCE == null爲了避免非必要加鎖，當第一次加載時纔對實例進行加鎖再實例化。這樣既可以節約內存空間，又可以保證線程安全。但是，由於jvm存在亂序執行功能，DCL也會出現線程不安全的情況。

具體分析如下：

INSTANCE  = new SingleTon();

這個步驟，其實在jvm裏面的執行分爲三步：

1.在堆內存開闢內存空間。
2.在堆內存中實例化SingleTon裏面的各個參數。
3.把對象指向堆內存空間。

由於jvm存在亂序執行功能，所以可能在2還沒執行時就先執行了3，如果此時再被切換到線程B上，由於執行了第3步，INSTANCE 已經非空了，會被直接拿出來用，這樣的話，就會出現異常。這個就是著名的DCL失效問題。

不過在JDK1.5之後，官方也發現了這個問題，故而具體化了volatile，即在JDK1.6及以後，只要定義爲

private volatile static SingleTon  INSTANCE = null;

就可解決DCL失效問題。volatile確保INSTANCE每次均在主內存中讀取，這樣雖然會犧牲一點效率，但也無傷大雅。

public class DoubleCheckLockLazySingleton {
    private static volatile DoubleCheckLockLazySingleton INSTANCE = null;

    private DoubleCheckLockLazySingleton() {
    }

    public static DoubleCheckLockLazySingleton getInstance() {
        if (INSTANCE == null) {
            synchronized (DoubleCheckLockLazySingleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new DoubleCheckLockLazySingleton();
                }
            }
        }
        return INSTANCE;
    }
}

靜態內部類模式

靜態內部類的優點是：外部類加載時並不需要立即加載內部類，內部類不被加載則不去初始化INSTANCE，故而不佔內存。即當SingleTon第一次被加載時，並不需要去加載SingleTonHoler，只有當getInstance()方法第一次被調用時，纔會去初始化INSTANCE,第一次調用getInstance()方法會導致虛擬機加載SingleTonHoler類，這種方法不僅能確保線程安全，也能保證單例的唯一性，同時也延遲了單例的實例化。

那麼，靜態內部類又是如何實現線程安全的呢？首先，我們先了解下類的加載時機。

類加載時機：JAVA虛擬機在有且僅有的5種場景下會對類進行初始化。

1.遇到new、getstatic、setstatic或者invokestatic這4個字節碼指令時，對應的java代碼場景爲：new一個關鍵字或者一個實例化對象時、讀取或設置一個靜態字段時(final修飾、已在編譯期把結果放入常量池的除外)、調用一個類的靜態方法時。
2.使用java.lang.reflect包的方法對類進行反射調用的時候，如果類沒進行初始化，需要先調用其初始化方法進行初始化。
3.當初始化一個類時，如果其父類還未進行初始化，會先觸發其父類的初始化。
4.當虛擬機啓動時，用戶需要指定一個要執行的主類(包含main()方法的類)，虛擬機會先初始化這個類。
5.當使用JDK 1.7等動態語言支持時，如果一個java.lang.invoke.MethodHandle實例最後的解析結果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，並且這個方法句柄所對應的類沒有進行過初始化，則需要先觸發其初始化。

這5種情況被稱爲是類的主動引用，注意，這裏《虛擬機規範》中使用的限定詞是"有且僅有"，那麼，除此之外的所有引用類都不會對類進行初始化，稱爲被動引用。靜態內部類就屬於被動引用的行列。

我們再回頭看下getInstance()方法，調用的是SingleTonHoler.INSTANCE，取的是SingleTonHoler裏的INSTANCE對象，跟上面那個DCL方法不同的是，getInstance()方法並沒有多次去new對象，故不管多少個線程去調用getInstance()方法，取的都是同一個INSTANCE對象，而不用去重新創建。當getInstance()方法被調用時，SingleTonHoler纔在SingleTon的運行時常量池裏，把符號引用替換爲直接引用，這時靜態對象INSTANCE也真正被創建，然後再被getInstance()方法返回出去，這點同餓漢模式。那麼INSTANCE在創建過程中又是如何保證線程安全的呢？在《深入理解JAVA虛擬機》中，有這麼一句話:

虛擬機會保證一個類的clinit方法在多線程環境中被正確地加鎖、同步，如果多個線程同時去初始化一個類，那麼只會有一個線程去執行這個類的clinit方法，其他線程都需要阻塞等待，直到活動線程執行clinit方法完畢。如果在一個類的clinit方法中有耗時很長的操作，就可能造成多個進程阻塞(需要注意的是，其他線程雖然會被阻塞，但如果執行clinit方法後，其他線程喚醒之後不會再次進入clinit方法。同一個加載器下，一個類型只會初始化一次。)，在實際應用中，這種阻塞往往是很隱蔽的。

故而，可以看出INSTANCE在創建過程中是線程安全的，所以說靜態內部類形式的單例可保證線程安全，也能保證單例的唯一性，同時也延遲了單例的實例化。

那麼，是不是可以說靜態內部類單例就是最完美的單例模式了呢？其實不然，靜態內部類也有着一個致命的缺點，就是傳參的問題，由於是靜態內部類的形式去創建單例的，故外部無法傳遞參數進去，例如Context這種參數，所以，我們創建單例時，可以在靜態內部類與DCL模式裏自己斟酌。

package com.phy.java.singleton;

/**
 * @author ：mmzs
 * @date ：Created in 2020/4/12 12:31
 * @description：靜態內部類實現單例模式
 * @modified By：
 * @version: $
 */
public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton(){}

    private static class SingleTonHoler{
        private static StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance(){
        return SingleTonHoler.INSTANCE;
    }
}

枚舉模式

優點：

代碼簡單
自由序列化

用enum實現Singleton時我曾介紹過三個特性，自由序列化，線程安全，保證單例

對於序列化和反序列化，因爲每一個枚舉類型和枚舉變量在JVM中都是唯一的，即Java在序列化和反序列化枚舉時做了特殊的規定，枚舉的writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法是被編譯器禁用的，因此也不存在實現序列化接口後調用readObject會破壞單例的問題。
對於線程安全方面，類似於普通的餓漢模式，通過在第一次調用時的靜態初始化創建的對象是線程安全的

package com.phy.java.singleton;

public enum ResponseDto {
    //定義兩個實例，一個表示請求成功，一個表示請求失敗
    HTTP_200(200,"請求成功"), HTTP_500(500,"請求失敗");

    //枚舉和普通的類一樣，可以定義屬性，構造函數，getter setter，普通方法，
    private Integer code;
    private String msg;

    ResponseDto(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public Integer getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public static void main(String [] args){
        System.out.println(ResponseDto.HTTP_200);
        System.out.println(ResponseDto.HTTP_500);
        System.out.println(ResponseDto.HTTP_200==ResponseDto.HTTP_200);
        System.out.println(ResponseDto.HTTP_200.equals(ResponseDto.HTTP_200));
        System.out.println(ResponseDto.HTTP_200.getMsg());
        System.out.println(ResponseDto.HTTP_500.getMsg());
    }
}

實現單例的幾種方式

餓漢模式：

懶漢模式：

雙重鎖懶漢模式：

靜態內部類模式

枚舉模式

SXSSFWorkbook Excel 大量數據導出

RestTemplate類

文檔類的導入導出(待補充)

Apache POI教程的使用

spring cloud 生產者與消費者之間的通信

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結