Java設計模式-單例模式

標籤：分析   餓漢式   緩衝   hold   lsp   實現   資料   new   volatile   

單例模式

作為對象的建立模式，單例模式確保某一個類只有一個執行個體，而且自行執行個體化並向整個系統提供這個執行個體。這個類稱為單例類。

單例模式的結構

• 單例類只能有一個執行個體
• 單例類必須自己建立自己的唯一執行個體
• 單例類必須給所有其他對象提供這一執行個體

餓漢式單例類

package com.tutorialspoint;public class EagerSinleton {    private static EagerSinleton instance = new EagerSinleton();    private EagerSinleton() {}    public static EagerSinleton getInstance() {        return instance;    }}

上面例子中，在這個類被載入時，靜態變數instance會被初始化，此時類的私人建構函式會被調用。這時候單例類的唯一執行個體就被建立出來了。

餓漢式其實是一種比較形象的稱謂。既然餓，那麼在建立對象執行個體的時候就比較著急，餓了，於是在裝載類的時候就建立對象執行個體。

private static EagerSinleton instance = new EagerSinleton();

餓漢式是典型的空間換時間，當類裝載的時候就會建立類的執行個體，不管你用不用，先建立出來，然後每次調用的時候，就不需要再判斷，節省了已耗用時間。

懶漢式單例類

package com.tutorialspoint;public class LazySingleton {    private static LazySingleton instance = null;        /*     * 私人預設構造     * */    private LazySingleton() {}        /*     * 靜態Factory 方法     * */    public static synchronized LazySingleton getInstance() {        if ( instance == null ) {            instance = new LazySingleton();        }         return instance;    }}

上面的懶漢式單例類實現對靜態Factory 方法使用同步化，以處理多線程環境。

懶漢式其實是一種比較形象的稱謂。既然懶，那麼在建立對象執行個體的時候就不著急。會一直等到馬上要使用對象執行個體的時候才會建立，懶人嘛，總是推脫不開的時候才會真正執行工作，因此在裝卸對象的時候不建立對象執行個體。

private static LazySingleton instance = null;

懶漢式是典型的時間換空間。就是每次擷取執行個體都會進行判斷，看是否需要建立執行個體，浪費判斷的時間。當然，如果一直沒有人使用的話，那就不會建立執行個體，則節約記憶體空間。

由於懶漢式的實現是安全執行緒的，這樣會降低整個訪問的速度，而且每次都要判斷。

雙重檢查加鎖

可以使用“雙重檢查加鎖”的方式來實現，就可以既實現安全執行緒，又能夠使效能不受很大的影響。那麼什麼是“雙重檢查加鎖”機制呢？

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

"雙重檢查加鎖"機制的實現會使用關鍵字“volatile”，它的意思是“被volatie修飾的變數的值將不會被本地線程緩衝，所有對該變數的讀寫都是直接操作共用記憶體”，從而確保多個線程能正確的出來該變數。

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

package com.tutorialspoint;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關鍵字可能會屏蔽掉虛擬機器中的一些必要的代碼最佳化，所以運行效率不是很高。因此一般建議，沒有特別的需要，不要使用，也就是說，雖然可以使用“雙重檢查加鎖”機制來實現安全執行緒的單例，但並不建議大量採用，可以根據情況來選用。

根據上面的分析，常見的兩種單例實現方式都存在小小的缺陷，那麼有沒有一種方案，技能實現消極式載入，又能實現安全執行緒呢？

Lay initialization holder class模式

這個模式綜合使用了Java的類級內部類和多線程預設同步鎖的知識，很巧妙的同事實現了消極式載入和安全執行緒。

什麼是類級內部類：

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

類級內部類相當於其外部類的static成分，它的對象與外部類對象之間不存在依賴關係，因此可以直接建立。而對象級內部類，是綁定在外部對象執行個體中的。

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

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

多線程預設同步鎖：

在多線程開發中，為瞭解決並發問題，主要通過使用synchronized來加互斥鎖進行同步控制。但是在某些情況中，JVM已經隱含的為您執行了同步，這些情況及不用自己來進行同步控制了。這些情況包括：

1. 由靜態初始化器（在靜態欄位是或static{}塊中的初始化器）初始化資料時
2. 訪問final欄位時
3. 在建立線程之前建立對象時
4. 線程可以看見它將要處理的對象時

解決方案：

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

如果現在有一種方法能讓類裝載的時候不去初始化對象，那就解決問題了，一種可行的方式是採用類級內部類，在這個類級內部類中去建立對象執行個體，這樣一來，只要不使用到這個類級內部類，那就不會建立對象執行個體，從而同時實現消極式載入和安全執行緒。

package com.tutorialspoint;public class Singleton {    private Singleton() {}        /*     * 類級內部類，也就是靜態成員式內部類，該內部類的執行個體與外部類的執行個體沒有綁定關係，而且只有被調用時才會裝載，從而實現了消極式載入     *      * */    private static class SingletonHolder{        /*         * 靜態初始化器，由JVM來保證安全執行緒         * */        private static Singleton instance = new Singleton();    }    public static Singleton getInstance() {        return SingletonHolder.instance;    }}

當getInstance()方法第一次被調用時，它第一次讀取SingletionHolder.instance，導致SingletonHolder類得到初始化；而這個類在裝載並初始化的時候，會初始化它的靜態域，從而建立Singletion的執行個體，由於是靜態，因此知乎在虛擬機器裝載類的時候初始化一次，並由虛擬機器來保證它的執行緒安全性。

這個模式的優勢在於，getInstance()方法並沒有被同步，並且只是執行一個域的訪問，因此延遲初始化並沒有增加任何訪問成本。

單例和枚舉

單元素的枚舉類型已經成為實現Singleton的最佳方法。用枚舉來實現單例非常簡單，只需要編寫一個包含單個元素的枚舉類型即可。

package com.tutorialspoint;public enum SingletonN {    /*     * 定義一個枚舉元素，它就代表了SingletionN的一個執行個體     * */    uniqueInstance;        /*     *單例可以有自己的操作     * */    public String singletonOperation() {        //功能處理        return "ssssssssssssssssssss";    }}

使用枚舉類可以實現單一實例控制更加簡潔，而且無償提供了序列化機制，並由JVM從根本上提供保障，絕對防止多次執行個體化，是更簡潔，高效，安全的實現單例的方式。

Java設計模式-單例模式