Java設(shè)計(jì)模式——單例模式

單例模式應(yīng)該是大家最為熟知的一種設(shè)計(jì)模式了，相信大家或多或少的都在自己的項(xiàng)目中使用過單例模式，例如封裝一個(gè)Log工具類、一個(gè)數(shù)據(jù)庫存取類或者用戶登錄管理類等。而我們使用單例模式主要有兩個(gè)目的：
1.減少內(nèi)存消耗
2.多個(gè)線程中保證共享資源的唯一性
單例模式的寫法有好多種，如：餓漢式單例模式、懶漢式單例模式、IoDH單例模式、枚舉式單例模式，下面就來一一實(shí)現(xiàn)下這些寫法。

餓漢式單例模式

public class HungrySingletonV1 {
    private static HungrySingletonV1 instance = new HungrySingletonV1();
    private HungrySingletonV1(){
    }
    public static HungrySingletonV1 getInstance(){
        return instance;
    }
}

上面的例子中，類被加載時(shí)，靜態(tài)變量instance就會(huì)被初始化，這時(shí)候單例類的唯一實(shí)例就被創(chuàng)建了。

優(yōu)點(diǎn)：類加載時(shí)就已經(jīng)實(shí)例化，避免了線程問題
缺點(diǎn)：由于類加載的時(shí)候就實(shí)例化了，沒有達(dá)到懶加載的效果，可能會(huì)造成內(nèi)存浪費(fèi)
餓漢式單例模式還要一種變種

public class HungrySingletonV2 {
    private static HungrySingletonV2 instance;
    static {
        instance = new HungrySingletonV2();
    }
    private HungrySingletonV2(){
    }
    
    public static HungrySingletonV2 getInstance(){
        return instance;
    }
}

效果與前面的一樣，不過把初始化方法放到靜態(tài)代碼塊中，也是在類加載時(shí)調(diào)用。

懶漢式單例模式

低配版

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

上面的代碼是最簡單的懶漢式單例模式，實(shí)現(xiàn)懶加載，每次獲取實(shí)例時(shí)會(huì)去判斷是否已創(chuàng)建實(shí)例，如果一直沒人用，則不用創(chuàng)建實(shí)例，節(jié)省內(nèi)存空間。

但實(shí)際上，上面這種寫法應(yīng)該是最不推薦的一種單例模式寫法。因?yàn)樗蔷€程不安全的，如果多個(gè)線程同時(shí)獲取該實(shí)例，就會(huì)創(chuàng)建多個(gè)實(shí)例對象，不符合單例的需求。

進(jìn)階版

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

可以看到在這種懶漢式單例模式中，我們在獲取實(shí)例的方法上加了一個(gè)同步鎖，這樣保證了獲取實(shí)例的方法在不同線程中是同步的，使得獲取的實(shí)例是唯一的。

但是這種寫法有一個(gè)最大的問題就是，效率太低。每一個(gè)線程都要進(jìn)行等待，而實(shí)際中，如果已經(jīng)創(chuàng)建了，后面的想獲取實(shí)例，直接返回就行。

再進(jìn)階版

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

基于前一個(gè)版本的問題，有人想到了將同步鎖置于instance為空判斷之后，這樣就實(shí)現(xiàn)了當(dāng)實(shí)例已經(jīng)創(chuàng)建，后面的獲取時(shí)直接返回的問題。

但是，這種寫法又導(dǎo)致了線程不安全。如果A用戶拿到了同步鎖，正在創(chuàng)建實(shí)例，另一個(gè)B用戶在實(shí)例還未創(chuàng)建時(shí)到了同步鎖外等候，當(dāng)A用戶創(chuàng)建完實(shí)例，退出同步鎖后，B用戶馬上就獲取了同步鎖并開始創(chuàng)建實(shí)例，這就導(dǎo)致了創(chuàng)建了多個(gè)實(shí)例。

終極版

//雙重校驗(yàn)鎖
public class LazySingletonV4 {
    private  volatile static LazySingletonV4 instance;
    private LazySingletonV4(){
    }
    public static LazySingletonV4 getInstance(){
        //檢查實(shí)例是否存在，不存在才進(jìn)入同步塊
        if(instance == null){
            //同步塊，保證線程安全
            synchronized(LazySingletonV4.class){
                //再次檢查實(shí)例是否存在，不存在才創(chuàng)建實(shí)例
                if(instance == null){
                    instance = new LazySingletonV4();
                }
            }
        }
        return instance;
    }
}

雙重校驗(yàn)算是懶漢式單例模式的終極版本了，先判斷實(shí)例是否為空，為空獲取同步鎖，在同步鎖內(nèi)再判斷一次實(shí)例是否為空，既保證了線程安全又提高了效率。

雙重校驗(yàn)加鎖的實(shí)現(xiàn)一般會(huì)使用關(guān)鍵字volatile，它的意思是：被volatile修飾的變量的值，將不會(huì)被本地線程緩存，所有對該變量的讀寫都是直接操作共享內(nèi)存，從而確保多個(gè)線程能正確的處理該變量。

IoDH單例模式

什么是IoDH呢？

IoDH是Initialization Demand Holder 的縮寫，簡單來說就是在單例類中增加一個(gè)靜態(tài)內(nèi)部類，在該內(nèi)部類中創(chuàng)建單例類的實(shí)例。

我們知道，在多線程開發(fā)時(shí)，為了解決并發(fā)問題，我們會(huì)使用synchronized來加互斥鎖進(jìn)行同步控制。但是在某些情況下，JVM已經(jīng)隱含為您執(zhí)行了同步，這些時(shí)候就不需要自己進(jìn)行同步控制了。這些情況包括：

由靜態(tài)初始化器（在靜態(tài)字段上或static{}塊中的初始化器）初始化數(shù)據(jù)時(shí)
訪問final字段時(shí)
在創(chuàng)建線程之前創(chuàng)建對象時(shí)
線程可以看見它將要處理的對象時(shí)
例如餓漢式單例模式，就是在類加載時(shí)進(jìn)行了初始化，也就是由靜態(tài)初始化器初始化的。但是餓漢式單例模式不符合懶加載的要求，如果可以讓類加載時(shí)不去初始化對象，不就解決問題了嗎。這就是IoDH的方法，通過定義一個(gè)靜態(tài)內(nèi)部類，在這個(gè)靜態(tài)內(nèi)部類中創(chuàng)建單例類實(shí)例，當(dāng)我們需要使用時(shí)才會(huì)去加載這個(gè)靜態(tài)內(nèi)部類，創(chuàng)建單例類實(shí)例。

public class IoDHSingleton {
    private IoDHSingleton() {
    }
    private static class SingletonHolder {
        /**
         * 靜態(tài)初始化器，由JVM來保證線程安全
         */
        private static IoDHSingleton instance = new IoDHSingleton();
    }
    public static IoDHSingleton getInstance() {
        return SingletonHolder.instance;
    }
}

當(dāng)getInstance方法第一次被調(diào)用的時(shí)候，它第一次讀取SingletonHolder.instance，導(dǎo)致SingletonHolder類得到初始化；而這個(gè)類在裝載并被初始化的時(shí)候，會(huì)初始化它的靜態(tài)域，從而創(chuàng)建IoDHSingleton的實(shí)例，由于是靜態(tài)的域，因此只會(huì)在虛擬機(jī)裝載類的時(shí)候初始化一次，并由虛擬機(jī)來保證它的線程安全性。

這個(gè)模式的優(yōu)勢在于，getInstance方法并沒有被同步，并且只是執(zhí)行一個(gè)域的訪問，因此延遲初始化并沒有增加任何訪問成本。

枚舉式單例模式

借助JDK1.5中添加的枚舉來實(shí)現(xiàn)單例模式，應(yīng)該是最好的實(shí)現(xiàn)單例模式的方式，代碼也很簡單。

public enum EnumSingleton {
    instance;
    public void method(){
        //功能方法
    }
}

訪問也很簡單，通過EnumSingleton.instance即可調(diào)用枚舉類中的方法了。這種單例模式不僅能避免多線程同步問題，而且還能防止反序列化重新創(chuàng)建新的對象。