程式師世界 >> 編程語言 >> JAVA編程 >> JAVA綜合教程 >> 如何正確書寫單例模式，正確書寫模式

如何正確書寫單例模式，正確書寫模式

編輯：JAVA綜合教程

如何正確書寫單例模式，正確書寫模式

單例模式算是設計模式中最容易理解，也是最容易手寫代碼的模式，但是其中涉及的知識點卻一點也不少，所以經常作為面試題來考。一般單例都是五種寫法：懶漢，餓漢，雙重校驗鎖，靜態內部類和枚舉。為了記錄學習過程的過程，這裡整理了幾種常見的單例寫法，

青銅5：（Lazy-loaded，但線程不安全）

當被問到要實現一個單例模式時，很多人的第一反應是寫出如下的代碼，包括教科書上也是這樣教我們的。

public class Singleton {
    private static Singleton instance;
    private Singleton(){}

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

這段代碼簡單明了，而且使用了延遲加載模式，但是線程不安全。多線程環境下調用 getInstance() 方法，可能會發生多個線程進入if語句的程序代碼塊。

懶漢式：synchronized（Lazy-loaded，線程安全，但不高效）

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

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（）方法，會導致潛在的性能問題。這就引出了雙重檢驗鎖。

餓漢式：static final field（非Lazy-loaded）

這種方法非常簡單，因為單例的實例被聲明成 static final，在第一次加載類到內存中時就會初始化，所以創建實例對象是線程安全的（由JVM實現保證）。

public class Singleton{
    //類加載時就初始化
    private static final Singleton instance = new Singleton();
    private Singleton(){}
    
    public static Singleton getInstance(){                       // Singleton with static factory
        return instance;
    }
}

它不是一種懶加載模式，instance會在加載類後一開始就被初始化，即使客戶端沒有調用 getInstance()方法。這會導致一些使用限制：譬如 Singleton 實例的創建是依賴參數或者配置文件的，在 getInstance() 之前必須調用某個方法設置參數給它，那樣這種單例寫法就無法使用了。類似的方法還有：

public class Singleton{
    public static final Singleton instance = new Singleton();    // Singleton with public final field
    private Singleton(){}
    
}
// <Effective Java>第14頁講訴了兩者的差異

雙重檢驗鎖 + volatile（Lazyload，線程安全，但晦澀）

雙重檢驗鎖模式（double checked locking pattern），是一種使用同步塊加鎖的方法。程序員稱其為雙重檢查鎖，因為會有兩次檢查 instance == null，一次是在同步塊外，一次是在同步塊內。為什麼在同步塊內還要再檢驗一次？因為可能會有多個線程一起進入同步塊外的 if，如果在同步塊內不進行二次檢驗的話就會生成多個實例對象了。

public static Singleton getSingleton() {
    if (instance == null) {                         //Single Checked
        synchronized (Singleton.class) {
            if (instance == null) {                 //Double Checked
                instance = new Singleton();
            }
        }
    }
    return instance ;
}

這段代碼看起來很完美，很可惜它是有問題的。主要在於instance = new Singleton()這句，這並非是一個原子操作，事實上在 JVM 中這句話大概做了下面 3 件事情。

但是在 JVM 的JIT編譯器中存在指令重排序的優化。也就是說上面的第二步和第三步的順序是不能保證的，最終的執行順序可能是 1-2-3 也可能是 1-3-2。如果是後者，則在 3 執行完畢、2未執行之前，被線程二搶占了，這時 instance 已經是非 null 了（但卻沒有初始化），所以線程二會直接返回 instance，然後使用，然後順理成章地報錯。為此，我們需要將 instance 變量聲明成 volatile 。

public class Singleton {
    private volatile static Singleton instance; //聲明為 volatile
    private Singleton(){}

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

但是特別注意在 Java 1.5 以前的版本使用了 volatile 的雙檢鎖還是有問題的，這個問題在 Java 1.5 中才得以修復，所以在這之後才可以放心使用 volatile。

靜態內部類：IoDH，initialization-on-demand holder

這個模式綜合使用了Java的靜態內部類和多線程缺省同步鎖的知識，很巧妙地同時實現了延遲加載和線程安全。

public class Singleton {
    private Singleton() {}

    private static class LazyHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {           // From wikipedia
        return LazyHolder.INSTANCE;
    }
}

靜態內部類相當於其外部類的static部分，它的對象不依賴於外部類對象，因此可以直接創建。靜態內部類只有在第一次被使用的時候才會被轉載。

多線程缺省同步鎖

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

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

　　2.訪問final字段時

　　3.在創建線程之前創建對象時

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