一、前言

作為對象的創(chuàng)建模式，單例模式確保某一個類只有一個實例，而且自行實例化并向整個系統(tǒng)提供這個實例。這個類稱為單例類。

單例模式的特點：
　　1. 單例類只能有一個實例。
　　2. 單例類必須自己創(chuàng)建自己的唯一實例。
　　3. 單例類必須給所有其他對象提供這一實例。

單例模式創(chuàng)建方式分為兩大類，餓漢式和懶漢，其中餓漢式比較簡單，懶漢式則需要考慮線程安全。

二、餓漢式單例

public class Singleton {
    private static Singleton instance = new Singleton();
    /**
     * 私有默認構造子
     */
    private Singleton(){}
    /**
     * 靜態(tài)工廠方法
     */
    public static Singleton getInstance(){
        return instance;
    }
}

上面的例子中，在這個類被加載時，靜態(tài)變量instance會被初始化，此時類的私有構造子會被調用。這時候，單例類的唯一實例就被創(chuàng)建出來了。

餓漢式是典型的空間換時間，當類裝載的時候就會創(chuàng)建類的實例，不管你用不用，先創(chuàng)建出來，然后每次調用的時候，就不需要再判斷，節(jié)省了運行時間。

餓漢式單例的缺點是它不是一種懶加載模式（lazy initialization），單例會在加載類后一開始就被初始化，即使客戶端沒有調用 getInstance()方法。餓漢式的創(chuàng)建方式在一些場景中將無法使用：譬如 Singleton 實例的創(chuàng)建是依賴參數或者配置文件的，在 getInstance() 之前必須調用某個方法設置參數給它，那樣這種單例寫法就無法使用了。

三、懶漢式單例

懶漢式由于是在運行的時候才實例化，因此在多線程運行環(huán)境下必須考慮到線程安全的問題，保證單例被正確的創(chuàng)建和獲取。

1. 懶漢式，線程不安全

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

這段代碼簡單明了，而且使用了懶加載模式，但是卻存在致命的問題。當有多個線程并行調用 getInstance() 的時候，就會創(chuàng)建多個實例。也就是說在多線程下不能正常工作。

2. 懶漢式，線程安全

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

為了解決上面的問題，最簡單的方法是將整個 getInstance() 方法設為同步（synchronized）。

雖然做到了線程安全，并且解決了多實例的問題，但是它并不高效。因為在任何時候只能有一個線程調用 getInstance() 方法。但是同步操作只需要在第一次調用時才被需要，即第一次創(chuàng)建單例實例對象時。這就引出了雙重檢驗鎖。

3. 雙重檢驗鎖

public class Singleton {
    private volatile static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        //先檢查實例是否存在，如果不存在才進入下面的同步塊
        if(instance == null){
            //同步塊，線程安全的創(chuàng)建實例
            synchronized (Singleton.class) {
                //再次檢查實例是否存在，如果不存在才真正的創(chuàng)建實例
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

可以使用“雙重檢查加鎖”的方式來實現(xiàn)，就可以既實現(xiàn)線程安全，又能夠使性能不受很大的影響。那么什么是“雙重檢查加鎖”機制呢？

所謂“雙重檢查加鎖”機制，指的是：并不是每次進入getInstance方法都需要同步，而是先不同步，進入方法后，先檢查實例是否存在，如果不存在才進行下面的同步塊，這是第一重檢查，進入同步塊過后，再次檢查實例是否存在，如果不存在，就在同步的情況下創(chuàng)建一個實例，這是第二重檢查。這樣一來，就只需要同步一次了，從而減少了多次在同步情況下進行判斷所浪費的時間。

“雙重檢查加鎖”機制的實現(xiàn)會使用關鍵字volatile，它的意思是：被volatile修飾的變量的值，將不會被本地線程緩存，所有對該變量的讀寫都是直接操作共享內存，從而確保多個線程能正確的處理該變量。

注意：在java1.4及以前版本中，很多JVM對于volatile關鍵字的實現(xiàn)的問題，會導致“雙重檢查加鎖”的失敗，因此“雙重檢查加鎖”機制只只能用在java5及以上的版本。

4. 靜態(tài)內部類

什么是類級內部類？

簡單點說，類級內部類指的是，有static修飾的成員式內部類。如果沒有static修飾的成員式內部類被稱為對象級內部類。

類級內部類相當于其外部類的static成分，它的對象與外部類對象間不存在依賴關系，因此可直接創(chuàng)建。而對象級內部類的實例，是綁定在外部對象實例中的。

類級內部類中，可以定義靜態(tài)的方法。在靜態(tài)方法中只能夠引用外部類中的靜態(tài)成員方法或者成員變量。

類級內部類相當于其外部類的成員，只有在第一次被使用的時候才被會裝載。

多線程缺省同步鎖的知識

大家都知道，在多線程開發(fā)中，為了解決并發(fā)問題，主要是通過使用synchronized來加互斥鎖進行同步控制。但是在某些情況中，JVM已經隱含地為您執(zhí)行了同步，這些情況下就不用自己再來進行同步控制了。這些情況包括：

1.由靜態(tài)初始化器（在靜態(tài)字段上或static{}塊中的初始化器）初始化數據時

2.訪問final字段時

3.在創(chuàng)建線程之前創(chuàng)建對象時

4.線程可以看見它將要處理的對象時

public class Singleton {
    
    private Singleton(){}
    /**
     *    類級的內部類，也就是靜態(tài)的成員式內部類，該內部類的實例與外部類的實例
     *    沒有綁定關系，而且只有被調用到時才會裝載，從而實現(xiàn)了延遲加載。
     */
    private static class SingletonHolder{
        /**
         * 靜態(tài)初始化器，由JVM來保證線程安全
         */
        private static Singleton instance = new Singleton();
    }
    
    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

要想很簡單地實現(xiàn)線程安全，可以采用靜態(tài)初始化器的方式，它可以由JVM來保證線程的安全性。比如前面的餓漢式實現(xiàn)方式。但是這樣一來，不是會浪費一定的空間嗎？因為這種實現(xiàn)方式，會在類裝載的時候就初始化對象，不管你需不需要。

如果現(xiàn)在有一種方法能夠讓類裝載的時候不去初始化對象，那不就解決問題了？一種可行的方式就是采用類級內部類，在這個類級內部類里面去創(chuàng)建對象實例。這樣一來，只要不使用到這個類級內部類，那就不會創(chuàng)建對象實例，從而同時實現(xiàn)延遲加載和線程安全。

5. 枚舉 Enum

public enum Singleton {
    /**
     * 定義一個枚舉的元素，它就代表了Singleton的一個實例。
     */
    
    uniqueInstance;
    
    /**
     * 單例可以有自己的操作
     */
    public void singletonOperation(){
        //功能處理
    }
}

我們可以通過EasySingleton.INSTANCE來訪問實例，這比調用getInstance()方法簡單多了。創(chuàng)建枚舉默認就是線程安全的，所以不需要擔心double checked locking，而且還能防止反序列化導致重新創(chuàng)建新的對象。