從未這麼明白的設計模式（一）：單例模式

什麼是單例？爲什麼要用單例？

一個類被設計出來，就代表它表示具有某種行爲（方法），屬性（成員變量），而一般情況下，當我們想使用這個類時，會使用new關鍵字，這時候jvm會幫我們構造一個該類的實例。而我們知道，對於new這個關鍵字以及該實例，相對而言是比較耗費資源的。所以如果我們能夠想辦法在jvm啓動時就new好，或者在某一次實例new好以後，以後不再需要這樣的動作，就能夠節省很多資源了。

哪些類可以使用單例？

一般而言，我們總是希望無狀態的類能夠設計成單例，那這個無狀態代表什麼呢？簡單而言，對於同一個實例，如果多個線程同時使用，並且不使用額外的線程同步手段，不會出現線程同步的問題，我們就可以認爲是無狀態的，再簡單點：一個類沒有成員變量，或者它的成員變量也是無狀態的，我們就可以考慮設計成單例。

實現方法

好了，我們已經知道什麼是單例，爲什麼要使用單例了，那我們接下來繼續討論下怎麼實現單例。
一般來說，我們可以把單例分爲行爲上的單例和管理上的單例。行爲上的單例代表不管如何操作（此處不談cloneable，反射），至始至終jvm中都只有一個類的實例，而管理上的單例則可以理解爲：不管誰去使用這個類，都要守一定的規矩，比方說，我們使用某個類，只能從指定的地方’去拿‘，這樣拿到就是同一個類了。
而對於管理上的單例，相信大家最爲熟悉的就是spring了，spring將所有的類放到一個容器中，以後使用該類都從該容器去取，這樣就保證了單例。
所以這裏我們剩下的就是接着來談談如何實現行爲上的單例了。一般來說，這種單例實現有兩種思路，私有構造器，枚舉。

枚舉實現單例

枚舉實現單例是最爲推薦的一種方法，因爲就算通過序列化，反射等也沒辦法破壞單例性，例子：

public enum SingletonEnum {
    INSTANCE;

    public static void main(String[] args) {
        System.out.println(SingletonEnum.INSTANCE == SingletonEnum.INSTANCE);
    }
}

結果自然是true，而如果我們嘗試使用反射破壞單例性：

public enum BadSingletonEnum {
    /**
     *
     */
    INSTANCE;

    public static void main(String[] args) throws Exception{
        System.out.println(BadSingletonEnum.INSTANCE == BadSingletonEnum.INSTANCE);

        Constructor<BadSingletonEnum> badSingletonEnumConstructor = BadSingletonEnum.class.getDeclaredConstructor();
        badSingletonEnumConstructor.setAccessible(true);
        BadSingletonEnum badSingletonEnum = badSingletonEnumConstructor.newInstance();

        System.out.println(BadSingletonEnum.INSTANCE == badSingletonEnum);
    }
}

結果如下：

Exception in thread "main" java.lang.NoSuchMethodException: cn.jsbintask.BadSingletonEnum.<init>()
    at java.lang.Class.getConstructor0(Class.java:3082)
    at java.lang.Class.getDeclaredConstructor(Class.java:2178)
    at cn.jsbintask.BadSingletonEnum.main(BadSingletonEnum.java:18)

異常居然是沒有init方法，這是爲什麼呢？那我們反編譯查看下這個枚舉類的字節碼：

// class version 52.0 (52)
// access flags 0x4031
// signature Ljava/lang/Enum<Lcn/jsbintask/BadSingletonEnum;>;
// declaration: cn/jsbintask/BadSingletonEnum extends java.lang.Enum<cn.jsbintask.BadSingletonEnum>
public final enum cn/jsbintask/BadSingletonEnum extends java/lang/Enum {

  // compiled from: BadSingletonEnum.java

  // access flags 0x4019
  public final static enum Lcn/jsbintask/BadSingletonEnum; INSTANCE

  // access flags 0x101A
  private final static synthetic [Lcn/jsbintask/BadSingletonEnum; $VALUES
}

結果發現這個枚舉類繼承了抽象類java.lang.Enum，我們接着看下Enum，發現構造器：

/**
    * Sole constructor.  Programmers cannot invoke this constructor.
    * It is for use by code emitted by the compiler in response to
    * enum type declarations.
    *
    * @param name - The name of this enum constant, which is the identifier
    *               used to declare it.
    * @param ordinal - The ordinal of this enumeration constant (its position
    *         in the enum declaration, where the initial constant is assigned
    *         an ordinal of zero).
*/
protected Enum(String name, int ordinal) {
    this.name = name;
    this.ordinal = ordinal;
}

那我們接着改變代碼，反射調用這個構造器：

public enum BadSingletonEnum {
    /**
     *
     */
    INSTANCE();

    public static void main(String[] args) throws Exception{
        System.out.println(BadSingletonEnum.INSTANCE == BadSingletonEnum.INSTANCE);

        Constructor<BadSingletonEnum> badSingletonEnumConstructor = BadSingletonEnum.class.getDeclaredConstructor(String.class, int.class);
        badSingletonEnumConstructor.setAccessible(true);
        BadSingletonEnum badSingletonEnum = badSingletonEnumConstructor.newInstance("test", 0);

        System.out.println(BadSingletonEnum.INSTANCE == badSingletonEnum);
    }
}

結果如下：

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
    at cn.jsbintask.BadSingletonEnum.main(BadSingletonEnum.java:21)

這次雖然方法找到了，但是直接給我們了一句Cannot reflectively create enum objects，不能夠反射創造枚舉對象，接着我們繼續看下newInstance（...）這個方法：

public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

關鍵代碼就是：if ((clazz.getModifiers() & Modifier.ENUM) != 0) throw new IllegalArgumentException("Cannot reflectively create enum objects");，所以就是jdk從根本上拒絕了使用反射去創建（知道爲啥java推薦使用enum實現單例了吧），另外，我們再觀察下Enum類的clone和序列化方法，如下：

protected final Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException();
}

private void readObject(ObjectInputStream in) throws IOException,
    ClassNotFoundException {
    throw new InvalidObjectException("can't deserialize enum");
}

private void readObjectNoData() throws ObjectStreamException {
    throw new InvalidObjectException("can't deserialize enum");
}

一眼看出，直接丟出異常，不允許這麼做！（真親兒子系列）。
所以，結論就是：枚舉是最靠譜的實現單例的方式！

私有構造器

另外一個實現單例最普通的方法則是私有構造器，開放獲取實例公共方法，雖然這種方法還是可以用clone，序列化，反射破壞單例性（除非特殊情況，我們不會這麼做），但是卻是最容易理解使用的。而這種方式又分了飽漢式，餓漢式。

餓漢式

看名字就知道，飢渴！（咳咳，開個玩笑），它指的是當一個類被jvm加載的時候就會被實例化，這樣可以從根本上解決多個線程的同步問題，例子如下：

public class FullSingleton {
    private static FullSingleton ourInstance = new FullSingleton();

    public static FullSingleton getInstance() {
        return ourInstance;
    }

    private FullSingleton() {
    }

    public static void main(String[] args) {
        System.out.println(FullSingleton.getInstance() == FullSingleton.getInstance());
    }
}

結果自然是true，雖然這種做法很方便的幫我們解決了多線程實例化的問題，但是缺點也很明顯，因爲這句代碼private static FullSingleton ourInstance = new FullSingleton();的關係，所以該類一旦被jvm加載就會馬上實例化，那如果我們不想用這個類怎麼辦呢？是不是就浪費了呢？既然這樣，我們來看下替代方案！飽漢式。

飽漢式

既然是飽，就代表它不着急，那我們可以這麼寫：

public class HungryUnsafeSingleton {
    private static HungryUnsafeSingleton instance;
    
    public static HungryUnsafeSingleton getInstance() {
        if (instance == null) {
            instance = new HungryUnsafeSingleton();
        }
        
        return instance;
    }
    
    private HungryUnsafeSingleton() {}
}

用意很容易理解，就是用到getInstance（）方法纔去檢查instance，如果爲null，就new一個，這樣就不怕浪費了，但是這個時候問題就來了：現在有這麼一種情況，在有兩個線程同時運行到了 instane == null這個語句，並且都通過了，那他們就會都實例化一個對象，這樣就又不是單例了。既然這樣，哪有什麼解決辦法呢？ 鎖方法

直接同步方法
這種方法比較乾脆利落，那就是直接在getInstance（）方法上加鎖，這樣就解決了線程問題：

public class HungrySafeSingleton {
    private static HungrySafeSingleton instance;

    public static synchronized HungrySafeSingleton getInstance() {
        if (instance == null) {
            instance = new HungrySafeSingleton();
        }

        return instance;
    }

    private HungrySafeSingleton() {
        System.out.println("HungryUnsafeSingleton.HungryUnsafeSingleton");
    }

    public static void main(String[] args) {
        System.out.println(HungrySafeSingleton.getInstance() == HungrySafeSingleton.getInstance());
    }
}

很簡單，很容易理解，加鎖，只有一個線程能實例該對象。但是，此時問題又來了，我們知道對於靜態方法而言，synchronized關鍵字會鎖住整個 Class，這時候又會有性能問題了（尼瑪墨跡），那有沒有優化的辦法呢？ 雙重檢查鎖：

public class HungrySafeSingleton {
    private static volatile HungrySafeSingleton instance;

    public static HungrySafeSingleton getInstance() {
        /* 使用一個本地變量可以提高性能 */
        HungrySafeSingleton result = instance;

        if (result == null) {

            synchronized (HungrySafeSingleton.class) {

                result = instance;
                if (result == null) {
                    instance = result = new HungrySafeSingleton();
                }
            }
        }

        return result;
    }

    private HungrySafeSingleton() {
        System.out.println("HungryUnsafeSingleton.HungryUnsafeSingleton");
    }

    public static void main(String[] args) {
        System.out.println(HungrySafeSingleton.getInstance() == HungrySafeSingleton.getInstance());
    }
}

用意也很明顯，synchronized關鍵字只加在了關鍵的地方，並且通過本地變量提高了性能（effective java），這樣線程安全並且不浪費資源的單例就完成了。

總結

本章，我們一步一步從什麼是單例，到爲什麼要使用單例，再到怎麼使用單例，並且從源碼角度分析了爲什麼枚舉是最適合的實現方式，然後接着講解了飽漢式，餓漢式的寫法以及好處，缺點。
例子源碼：https://github.com/jsbintask22/design-pattern-learning.git
本文原創地址：https://jsbintask.cn/2019/01/29/designpattern/singleton/，轉載請註明出處。
如果你覺得有用，歡迎關注，分享！

從未這麼明白的設計模式（一）：單例模式

什麼是單例？爲什麼要用單例？

哪些類可以使用單例？

實現方法

枚舉實現單例

私有構造器

餓漢式

飽漢式

總結

認知提升的方法

螞蟻面試：Springcloud核心組件的底層原理，你知道多少？

C#開源的兩款功能強大的錄屏神器

netty極簡教程（七）：Netty中的Selector是如何配合NioEventLoop工作的

netty極簡教程（六）：Netty是如何屏蔽ServerSocketChannel啓動的

netty極簡教程（五）：Netty的Reactor模型演進及JDK nio聊天室實現

netty極簡教程（四）：Selector事件驅動以及SocketChannel的使用

netty極簡教程（二）： nio Buffer的原理及使用

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

linux以太網驅動總結