《JAVA與模式》之單例模式

時間 2019-12-10

標籤 JAVA與模式模式欄目 Java 简体版

原文原文鏈接

在閻宏博士的《JAVA與模式》一書中開頭是這樣描述單例模式的：java

　　做爲對象的建立模式，單例模式確保某一個類只有一個實例，並且自行實例化並向整個系統提供這個實例。這個類稱爲單例類。緩存

單例模式的結構

　　單例模式的特色：安全

單例類只能有一個實例。
單例類必須本身建立本身的惟一實例。
單例類必須給全部其餘對象提供這一實例。

　餓漢式單例類

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

上面的例子中，在這個類被加載時，靜態變量instance會被初始化，此時類的私有構造子會被調用。這時候，單例類的惟一實例就被建立出來了。多線程

　　餓漢式實際上是一種比較形象的稱謂。既然餓，那麼在建立對象實例的時候就比較着急，餓了嘛，因而在裝載類的時候就建立對象實例。併發

private static EagerSingleton instance = new EagerSingleton();

　　餓漢式是典型的空間換時間，當類裝載的時候就會建立類的實例，無論你用不用，先建立出來，而後每次調用的時候，就不須要再判斷，節省了運行時間。性能

　　懶漢式單例類

public class LazySingleton {
    private static LazySingleton instance = null;
    /**
     * 私有默認構造子
     */
    private LazySingleton(){}
    /**
     * 靜態工廠方法
     */
    public static synchronized LazySingleton getInstance(){
        if(instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

上面的懶漢式單例類實現裏對靜態工廠方法使用了同步化，以處理多線程環境。
　　懶漢式實際上是一種比較形象的稱謂。既然懶，那麼在建立對象實例的時候就不着急。會一直等到立刻要使用對象實例的時候纔會建立，懶人嘛，老是推脫不開的時候纔會真正去執行工做，所以在裝載對象的時候不建立對象實例。優化

private static LazySingleton instance = null;

　　懶漢式是典型的時間換空間,就是每次獲取實例都會進行判斷，看是否須要建立實例，浪費判斷的時間。固然，若是一直沒有人使用的話，那就不會建立實例，則節約內存空間spa

　　因爲懶漢式的實現是線程安全的，這樣會下降整個訪問的速度，並且每次都要判斷。那麼有沒有更好的方式實現呢？線程

　　雙重檢查加鎖

　　可使用「雙重檢查加鎖」的方式來實現，就能夠既實現線程安全，又可以使性能不受很大的影響。那麼什麼是「雙重檢查加鎖」機制呢？code

　　所謂「雙重檢查加鎖」機制，指的是：並非每次進入getInstance方法都須要同步，而是先不一樣步，進入方法後，先檢查實例是否存在，若是不存在才進行下面的同步塊，這是第一重檢查，進入同步塊事後，再次檢查實例是否存在，若是不存在，就在同步的狀況下建立一個實例，這是第二重檢查。這樣一來，就只須要同步一次了，從而減小了屢次在同步狀況下進行判斷所浪費的時間。

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

　　注意：在java1.4及之前版本中，不少JVM對於volatile關鍵字的實現的問題，會致使「雙重檢查加鎖」的失敗，所以「雙重檢查加鎖」機制只只能用在java5及以上的版本。

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

這種實現方式既能夠實現線程安全地建立實例，而又不會對性能形成太大的影響。它只是第一次建立實例的時候同步，之後就不須要同步了，從而加快了運行速度。

　　提示：因爲volatile關鍵字可能會屏蔽掉虛擬機中一些必要的代碼優化，因此運行效率並非很高。所以通常建議，沒有特別的須要，不要使用。也就是說，雖然可使用「雙重檢查加鎖」機制來實現線程安全的單例，但並不建議大量採用，能夠根據狀況來選用。

　　根據上面的分析，常見的兩種單例實現方式都存在小小的缺陷，那麼有沒有一種方案，既能實現延遲加載，又能實現線程安全呢？

　　Lazy initialization holder class模式

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

　　1.相應的基礎知識

　什麼是類級內部類？

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

　　類級內部類至關於其外部類的static成分，它的對象與外部類對象間不存在依賴關係，所以可直接建立。而對象級內部類的實例，是綁定在外部對象實例中的。

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

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

　多線程缺省同步鎖的知識

　　你們都知道，在多線程開發中，爲了解決併發問題，主要是經過使用synchronized來加互斥鎖進行同步控制。可是在某些狀況中，JVM已經隱含地爲您執行了同步，這些狀況下就不用本身再來進行同步控制了。這些狀況包括：

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

　　2.訪問final字段時

　　3.在建立線程以前建立對象時

　　4.線程能夠看見它將要處理的對象時

　　2.解決方案的思路

　　要想很簡單地實現線程安全，能夠採用靜態初始化器的方式，它能夠由JVM來保證線程的安全性。好比前面的餓漢式實現方式。可是這樣一來，不是會浪費必定的空間嗎？由於這種實現方式，會在類裝載的時候就初始化對象，無論你需不須要。

　　若是如今有一種方法可以讓類裝載的時候不去初始化對象，那不就解決問題了？一種可行的方式就是採用類級內部類，在這個類級內部類裏面去建立對象實例。這樣一來，只要不使用到這個類級內部類，那就不會建立對象實例，從而同時實現延遲加載和線程安全。

　　示例代碼以下：

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

當getInstance方法第一次被調用的時候，它第一次讀取SingletonHolder.instance，致使SingletonHolder類獲得初始化；而這個類在裝載並被初始化的時候，會初始化它的靜態域，從而建立Singleton的實例，因爲是靜態的域，所以只會在虛擬機裝載類的時候初始化一次，並由虛擬機來保證它的線程安全性。

　　這個模式的優點在於，getInstance方法並無被同步，而且只是執行一個域的訪問，所以延遲初始化並無增長任何訪問成本。

　　單例和枚舉

　　按照《高效Java 第二版》中的說法：單元素的枚舉類型已經成爲實現Singleton的最佳方法。用枚舉來實現單例很是簡單，只須要編寫一個包含單個元素的枚舉類型便可。

public enum Singleton {
    /**
     * 定義一個枚舉的元素，它就表明了Singleton的一個實例。
     */
    
    uniqueInstance;
    
    /**
     * 單例能夠有本身的操做
     */
    public void singletonOperation(){
        //功能處理
    }
}