單例模式也是一種創建型模式，而且也非常容易理解：在一個系統中可能需要多個配置文件，我們希望這些配置文件的實例只存在一個，而不是存在多個重復的實例。這時候就需要使用單例模式。

單例模式有幾個要點：

• 一是必須確保只存在一個類的實例。
• 二是類必須自己創建自己，不允許其他類來創建自己。
• 三是必須提供一個方法允許其他類訪問單例成員。

根據這些特點，我們可以很容易猜出單例類在Java的樣子：首先他的構造方法必須是私有的，然后往往需要一個公有的靜態方法獲取單例實例。

單例的實現

單例模式的實現有很多種，按照單例的實例化的時機可以分為餓漢式和懶漢式兩種，下面來逐一說明。

懶漢式（非線程安全）

這種方式非常簡單，也很容易理解。單例實例在第一次調用的時候才創建，符合懶加載的要求。唯一缺點是這種方式不支持多線程，在多線程環境下可能會創建多個對象。

public class UnThreadSafeSingleton {
    private UnThreadSafeSingleton() {
    }

    private static UnThreadSafeSingleton singleton;

    public static UnThreadSafeSingleton getSingleton() {
        if (singleton == null) {
            singleton = new UnThreadSafeSingleton();
        }
        return singleton;
    }
}

懶漢式（同步的）

我們可以對上面的實現方式進行改進，以便在多線程環境下也可以正常工作。實現方式很簡單，直接在方法上添加synchronized關鍵字即可。

這種實現方式雖然也很簡單，但是性能不咋地。由于直接在方法上加了鎖，所以如果同時有兩個地方獲取單例對象，其中一個就會阻塞。在獲取單例的次數獲取比較多的時候性能很差。

public class SynchronizedThreadSafeSingleton {
    private static SynchronizedThreadSafeSingleton singleton;

    private SynchronizedThreadSafeSingleton() {

    }

    public synchronized static SynchronizedThreadSafeSingleton getSingleton() {
        if (singleton == null) {
            singleton = new SynchronizedThreadSafeSingleton();
        }
        return singleton;
    }
}

餓漢式（靜態初始化）

如果不要求必須懶加載，那么我們可以使用JVM的類加載工作機制，方便的實現單例模式。

JVM在第一次加載類的時候，會被初始化累的靜態域，并確保靜態域只初始化一次。所以我們可以將創建單例的代碼放到靜態初始化塊中，這樣JVM會幫我們創建單例。這種方式的缺點就是加載類的時候就創建了單例對象，沒有懶加載。

public class FirstLoadSingleton {
    private static FirstLoadSingleton singleton;

    private FirstLoadSingleton() {
    }

    static {
        singleton = new FirstLoadSingleton();
    }

    public static FirstLoadSingleton getSingleton() {
        return singleton;
    }
}

雙檢鎖方式

這種方式比較復雜，但是其他方面都很好：既實現了懶加載，同時也是線程安全的，性能還不錯。

雙檢鎖模式的要點：一是單例必須使用volatile關鍵字標記；二是在創建單例的時候要進行兩次檢查（這就是雙檢鎖的含義）。我們可以看到同步塊在第一次判斷之后，也就是說只有在第一次調用時才可能發生競爭和阻塞。單例創建之后，在獲取單例的時候不會調用同步塊，因此速度會非?？?。和前面的直接在方法上添加同步的例子相比，真是不知道高到哪里去了。

public class DoubleCheckLockSingleton {
    private volatile static DoubleCheckLockSingleton singleton;

    private DoubleCheckLockSingleton() {
    }

    public static DoubleCheckLockSingleton getSingleton() {
        if (singleton == null) {
            synchronized (DoubleCheckLockSingleton.class) {
                if (singleton == null) {
                    singleton = new DoubleCheckLockSingleton();
                }
            }
        }
        return singleton;
    }
}

靜態內部類方式

這種方式和雙檢鎖方式的效果類似，既可以保證懶加載又具有多線程下的性能優勢。而且實現起來更加簡單。唯一缺點就是單例對象必須是靜態的，而雙檢鎖方式的單例對象可以是實例的。

道理也很簡單，如果我們把單例放到類的靜態字段上，不能保證延遲加載的話，那么再用一層內部類包住不就行了。這樣，當外層類第一次加載的時候，不會觸發單例的初始化。而在第一次獲取單例的時候，才會調用內部類，從而讓JVM加載單例。

public class InnerClassSingleton {
    private static class Inner {
        private static InnerClassSingleton singleton = new InnerClassSingleton();
    }

    private InnerClassSingleton() {
    }

    public static InnerClassSingleton getSingleton() {
        return Inner.singleton;
    }
}

枚舉方式

這種方式是Java實現單例最好的方式，連《Effective Java》都推薦我們使用這種方式。不過現在貌似使用的還是比較少。一來，枚舉是Java 1.5才加入的東西；二來，Java的枚舉使用起來確實很捉急。甚至有些開發實踐都要求不使用枚舉，而是使用共有靜態字段來代替。所以枚舉單例這種方式就比較稀少了。

不過確實，Java的枚舉天生就是為實現單例而存在的。首先，枚舉的實例是在使用時才被初始化的，這和單例模式延遲加載的要求相符。其次，枚舉類型只允許存在私有的構造函數，從根本上杜絕了創建多個單例的可能性。而且當枚舉序列化和反序列化的時候，同樣會保證單例的唯一性。因此我們說，枚舉方式是Java實現單例最好的方式。

可能還是不太好理解，所以還是直接看代碼吧。假設我們需要一個單例的配置對象，我們可以創建枚舉來解決。枚舉的構造方法默認（且只能）是私有的，我們直接在構造方法中初始化數據（例如從文件讀取等等），然后通過枚舉類中定義的方法來讀取數據。如果對Java的枚舉還是感覺到比較陌生的話回去復習一下枚舉類的用法。

public enum EnumSingleton {
    Instance;

    private String data;

    EnumSingleton() {
        //在構造方法中進行初始化
        data = "Some data";
    }

    public String getData() {
        return data;
    }
}

當然在現在的Java生態中單例模式一般不需要我們手動實現了。像Spring和Guice這樣的依賴注入框架已經實現了單例模式，所以我們在使用這些框架的時候，創建和確保單例的工作有這些框架完成，我們只需要編寫傳統的非線程安全類即可。