摘要：常規設計模式之單例模式

前言

設計模式作為我們開發人員必不可少的編程思想，我們有必要好好的去學習、理解和掌握。今天開始我會整理自己所有學習過和沒有學習過的設計模式，希望大家一起多多交流。

這一章主要介紹我們常用的單例模式，它解決了我們需要反復獲取那些占用較大資源和開銷的對象的問題。并且單例出來的對象往往持有我們需要的一些狀態供我們使用。

單例分類

1. 餓漢式

餓漢式單例模式是基于classloder機制避免了多線程的同步問題。但是，instance在類裝載時就會實例化，這時候初始化instance是沒有達到lazy loading的效果的。

public final class HungrySingleton {

    /* 還有一種方式是在靜態代碼塊中進行demo的初始化，但是在
        多線程操作時，會出現空引用問題。
    */
    private static final HungrySingleton demo = new HungrySingleton();
    
    private HungrySingleton(){}

    public static HungrySingleton getInstance(){
        return demo;
    }
}

2. 懶漢式

• 線程不安全的懶漢式，實例化方法在多線程訪問時可能出現多實例，測試時出現多實例的概率雖然小，但是線程不安全

public final class LazyLoadingUnSafety {

    private static LazyLoadingUnSafety lazyLoading;

    private LazyLoadingUnSafety(){}

    public static LazyLoadingUnSafety getInstance(){
        if (lazyLoading == null){
            lazyLoading = new LazyLoadingUnSafety();
        }
        return lazyLoading;
    }
}

• 線程安全的懶漢式

public final class LazyLoadingSafe {

    private static LazyLoadingSafe lazyLoading;

    private LazyLoadingSafe(){
        // 避免通過反射進行實例的初始化
        if (lazyLoading == null) {
            lazyLoading = this;
        } else {
            throw new IllegalStateException("Already initialized.");
        }
    }

    /**
     * 通過synchronized 關鍵字進行實例化方法的線程安全
     * @return LazyLoadingSafe 返回的單實例
     */
    public static synchronized LazyLoadingSafe getInstance(){
        if (lazyLoading == null){
            lazyLoading = new LazyLoadingSafe();
        }
        return lazyLoading;
    }

}

3. 靜態內部類

利用了classloder的機制來保證初始化instance時只有一個線程，虛擬機會保證一個類的類構造器clinit()在多線程環境中被正確的加鎖、同步，如果多個線程同時去初始化一個類，那么只會有一個線程去執行這個類的類構造器clinit()，其他線程都需要阻塞等待，直到活動線程執行clinit()方法完畢。

public final class InnerClassSingleton {

    private InnerClassSingleton(){}

    public static InnerClassSingleton getInstance(){
        return SingletonHolder.instance;
    }

    private static class SingletonHolder {
        public static final InnerClassSingleton instance = new InnerClassSingleton();
    }
}

4. 枚舉單例

枚舉形式單例，解決多線程和能防止反序列化重新創建新的對象的單例模式, 此方式是線程安全的，但是添加其他方法就需要開發者去自己保證方法的線程安全。

public class EnumSingleton {

    private int tickets = 1000;

    private EnumSingleton(){}

    public static EnumSingleton getInstance(){
        return Singleton.SINGLETON.getInstance();
    }

    // 線程不安全
    public int getTickets(){
        return tickets++;
    }
    
    enum Singleton {

        SINGLETON;

        private EnumSingleton enumSingleton;

        Singleton() {
            this.enumSingleton = new EnumSingleton();
        }

        private EnumSingleton getInstance(){
            return this.enumSingleton;
        }
    }

5. 雙重檢索單例

通過在實例化方法中增加鎖進行線程安全保護，而實例變量singleton需要通過volatile關鍵字防止實例化方法在執行時進行指令重排出現線程安全問題。

public final class DoubleLockSingleton {

    // 不使用volatile 可能發生指令重排導致socket沒有被初始化完畢報空指針異常
    private static volatile DoubleLockSingleton singleton;

    private Socket socket;

    private DoubleLockSingleton(){

        // 此處阻止通過反射實例化實例
        if (singleton != null) {
            throw new IllegalStateException("Already initialized.");
        }
        this.socket = new Socket();
    }

    public static DoubleLockSingleton getInstance(){

        // 避免每次進入都需要進入同步代碼塊，提高效率
        if (singleton == null){
            synchronized(DoubleLockSingleton.class){
                if (singleton == null) {
                    singleton = new DoubleLockSingleton();
                }
            }
        }
        return singleton;
    }
}

6. CAS 線程安全單例

最新學習的單例實現方式，主要通過java提供的cas機制保證去實例化對象的時候為最新對象。

public class CASSingleton {

    private static final AtomicReference<CASSingleton> INSTANCE = new AtomicReference<>();

    public CASSingleton() {
    }

    public static final CASSingleton getInstance() {
        for (;;) {
            CASSingleton currentInstance = INSTANCE.get();

            if (currentInstance != null) {
                return currentInstance;
            }

            currentInstance = new CASSingleton();

            if (INSTANCE.compareAndSet(null, currentInstance)) {
                return currentInstance;
            }
        }
    }

總結

單例模式在我們日常開發代碼中會大量使用，即使沒有自己經常去創建單例，但在我們所使用的各種框架中被大量，比如spring等。這種模式值得我們好好去總結與學習。

還看到一篇文章使用ThreadLocal進行單例模式的設計，但是在我目前的知識體系中，ThreadLocal為每個線程提供變量的一個副本，也就是我們存到ThreadLocal中的對象會以副本的形式被每個線程使用，最終的測試結果是不同線程使用的對象是不一致的，我個人認為這種單例she設計不太合理，各位大佬可以提提意見。

public class ThreadLocalSingleton {

    private static final ThreadLocal<ThreadLocalSingleton> local = ThreadLocal.withInitial(() -> new ThreadLocalSingleton());

    private ThreadLocalSingleton(){
    }

    public static ThreadLocalSingleton getInstance(){
        return local.get();
    }
}

Github地址：詳細代碼可以參考我的GitHub，謝謝大佬指正