再看JAVA 設計模式-單例【轉】

單例模式你們並不陌生，也都知道它分爲何懶漢式、餓漢式之類的。可是你對單例模式的理解足夠透徹嗎？今天我帶你們一塊兒來看看我眼中的單例，可能會跟你的認識有所不一樣。

下面是一個簡單的小實例：

 

//簡單懶漢式
public class Singleton {

    //單例實例變量
    private static Singleton instance = null;

    //私有化的構造方法，保證外部的類不能經過構造器來實例化
    private Singleton() {}

    //獲取單例對象實例
    public static Singleton getInstance() {

        if (instance == null) {
            instance = new Singleton();
        }

        System.out.println("我是簡單懶漢式單例！");
        return instance;
    }
}

很容易看出，上面這段代碼在多線程的狀況下是不安全的，當兩個線程進入if (instance == null)時，兩個線程都判斷instance爲空，接下來就會獲得兩個實例了。這不是咱們想要的單例。

 

 

接下來咱們用加鎖的方式來實現互斥，從而保證單例的實現。

//同步法懶漢式
public class Singleton {

    //單例實例變量
    private static Singleton instance = null;

    //私有化的構造方法，保證外部的類不能經過構造器來實例化
    private Singleton() {}

    //獲取單例對象實例
    public static synchronized  Singleton getInstance() {

        if (instance == null) {
            instance = new Singleton();
        }

        System.out.println("我是同步法懶漢式單例！");
        return instance;
    }
}

加上synchronized後確實保證了線程安全，可是這樣就是最好的方法嗎？很顯然它不是，由於這樣一來每次調用getInstance()方法是都會被加鎖，而咱們只須要在第一次調用getInstance()的時候加鎖就能夠了。這顯然影響了咱們程序的性能。咱們繼續尋找更好的方法。

 

通過分析發現，只須要保證instance = new Singleton()是線程互斥就能夠保證線程安全，因此就有了下面這個版本：

//雙重鎖定懶漢式
public class Singleton {

    //單例實例變量
    private static Singleton instance = null;

    //私有化的構造方法，保證外部的類不能經過構造器來實例化
    private Singleton() {}

    //獲取單例對象實例
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        System.out.println("我是雙重鎖定懶漢式單例！");
        return instance;
    }
}

此次看起來既解決了線程安全問題，又不至於每次調用getInstance()都會加鎖致使下降性能。看起來是一個完美的解決方案，事實上是這樣的嗎？

很遺憾，事實並不是咱們想的那麼完美。java平臺內存模型中有一個叫「無序寫」（out-of-order writes）的機制。正是這個機制致使了雙重檢查加鎖方法的失效。這個問題的關鍵在上面代碼上的第5行：instance = new Singleton(); 這行其實作了兩個事情：一、調用構造方法，建立了一個實例。二、把這個實例賦值給instance這個實例變量。可問題就是，這兩步jvm是不保證順序的。也就是說。可能在調用構造方法以前，instance已經被設置爲非空了。下面咱們一塊兒來分析一下：

 

假設有兩個線程A、B

一、線程A進入getInstance()方法。

二、由於此時instance爲空，因此線程A進入synchronized塊。

三、線程A執行 instance = new Singleton(); 把實例變量instance設置成了非空。（注意，是在調用構造方法以前。）

四、線程A退出，線程B進入。

五、線程B檢查instance是否爲空，此時不爲空（第三步的時候被線程A設置成了非空）。線程B返回instance的引用。（問題出現了，這時instance的引用並非Singleton的實例，由於沒有調用構造方法。） 

六、線程B退出，線程A進入。

七、線程A繼續調用構造方法，完成instance的初始化，再返回。 

 

難道就沒有一個好方法了嗎？好的方法確定是有的，咱們繼續探索！

//解決無序寫問題懶漢式
public class Singleton {

    //單例實例變量
    private static Singleton instance = null;

    //私有化的構造方法，保證外部的類不能經過構造器來實例化
    private Singleton() {}

    //獲取單例對象實例
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {                  //1
                Singleton temp = instance;                //2
                if (temp == null) {
                    synchronized (Singleton.class) {  //3
                        temp = new Singleton();   //4
                    }
                    instance = temp;                  //5
                }
            }
        }
        System.out.println("我是解決無序寫懶漢式單例！");
        return instance;
    }
}

一、線程A進入getInstance()方法。

二、由於instance是空的 ，因此線程A進入位置//1的第一個synchronized塊。

三、線程A執行位置//2的代碼，把instance賦值給本地變量temp。instance爲空，因此temp也爲空。 

四、由於temp爲空，因此線程A進入位置//3的第二個synchronized塊。（後來想一想這個鎖有點多餘）

五、線程A執行位置//4的代碼，把temp設置成非空，但尚未調用構造方法！（「無序寫」問題） 

六、若是線程A阻塞，線程B進入getInstance()方法。

七、由於instance爲空，因此線程B試圖進入第一個synchronized塊。但因爲線程A已經在裏面了。因此沒法進入。線程B阻塞。

八、線程A激活，繼續執行位置//4的代碼。調用構造方法。生成實例。

九、將temp的實例引用賦值給instance。退出兩個synchronized塊。返回實例。

十、線程B激活，進入第一個synchronized塊。

十一、線程B執行位置//2的代碼，把instance實例賦值給temp本地變量。

十二、線程B判斷本地變量temp不爲空，因此跳過if塊。返回instance實例。

 

到此爲止，上面的問題咱們是解決了，可是咱們忽然發現爲了解決線程安全問題，但給人的感受就像身上纏了不少毛線.... 亂糟糟的，因此咱們要精簡一下：

//餓漢式
public class Singleton {

    //單例變量 ,static的，在類加載時進行初始化一次，保證線程安全
    private static Singleton instance = new Singleton();

    //私有化的構造方法，保證外部的類不能經過構造器來實例化。
    private Singleton() {}

    //獲取單例對象實例
    public static Singleton getInstance() {
        System.out.println("我是餓漢式單例！");
        return instance;
    }
}

看到上面的代碼，瞬間以爲這個世界清靜了。不過這種方式採用的是餓漢式的方法，就是預先聲明Singleton對象，這樣帶來的一個缺點就是：若是構造的單例很大，構造完又遲遲不使用，會致使資源浪費。

 

到底有沒有完美的方法呢？繼續看：

//內部類實現懶漢式
public class Singleton {

    private static class SingletonHolder{
        //單例變量
        private static Singleton instance = new Singleton();
    }

    //私有化的構造方法，保證外部的類不能經過構造器來實例化。
    private Singleton() {

    }

    //獲取單例對象實例
    public static Singleton getInstance() {
        System.out.println("我是內部類單例！");
        return SingletonHolder.instance;
    }
}

懶漢式（避免上面的資源浪費）、線程安全、代碼簡單。由於java機制規定，內部類SingletonHolder只有在getInstance()方法第一次調用的時候纔會被加載（實現了lazy），並且其加載過程是線程安全的（實現線程安全）。內部類加載的時候實例化一次instance。

 

簡單說一下上面提到的無序寫，這是jvm的特性，好比聲明兩個變量，String a; String b; jvm可能先加載a也可能先加載b。同理，instance = new Singleton();可能在調用Singleton的構造函數以前就把instance置成了非空。這是不少人會有疑問，說尚未實例化出Singleton的一個對象，那麼instance怎麼就變成非空了呢？它的值如今是什麼呢？想了解這個問題就要明白instance = new Singleton();這句話是怎麼執行的，下面用一段僞代碼向你們解釋一下：

 

mem = allocate();             //爲Singleton對象分配內存。
instance = mem;               //注意如今instance是非空的，可是尚未被初始化。

ctorSingleton(instance);    //調用Singleton的構造函數，傳遞instance.

 

 

因而可知當一個線程執行到instance = mem; 時instance已爲非空，若是此時另外一個線程進入程序判斷instance爲非空，那麼直接就跳轉到return instance;而此時Singleton的構造方法還未調用instance，如今的值爲allocate();返回的內存對象。因此第二個線程獲得的不是Singleton的一個對象，而是一個內存對象。