Java設計模式系列之單例模式

單例模式的定義

一個類有且僅有一個實例，而且自行實例化向整個系統提供。好比，多程序讀取一個配置文件時，建議配置文件時，建議配置文件封裝成對象。會方便操做其中的數據，又要保證多個程序讀到的是同一個配置文件對象，就須要該配置文件對象在內存中是惟一的。

單例模式的做用

簡單說來，單例模式（也叫單件模式）的做用就是保證在整個應用程序的生命週期中，任何一個時刻，單例類的實例都只存在一個（固然也能夠不存在）。

單例模式的類圖

                                                         

如何保證對象的惟一性

思想：(1)不讓其餘程序建立該類對象;

　　　(2)在本類中建立一個本類對象;

　　  (3)對外提供方法，讓其餘程序獲取這個對象;

步驟：(1)由於建立對象都須要構造函數初始化，只要將本類中的構造函數私有化，其餘程序就沒法再建立該類的對象;

　　　(2)就在類中建立一個本類的對象;

　　  (3)定義一個方法，返回該對象，讓其餘程序能夠經過方法獲得本類的對象(做用：可控,本類對象的產生由本身來決定，別誰想new就new)

【溫情提示】：咱們若是把代碼寫成這樣，用戶端獲取到getInstance方法不是也能夠獲取不少的類對象嗎?這不就不是單例了嗎?

public class Car {

    private Car(){
        
    }
    public static  Car getInstance(){
        return new Car();
    }
}

因此咱們直接本身在類中本身建立一個對象，getInstance方法只負責把對象返回給調用者，徹底實現單例可控(你能獲取個人方法，可是能拿到的是我本身建立好的對象)

public class Car {

    private static Car car=new Car();
    private Car(){
        
    }
    public static  Car getInstance(){
        return car;
    }
}

代碼體現：

　　　(1)私有化構造函數

　　  (2)建立私有並靜態的本類的對象

　　　(3)定義公有並靜態的方法，返回該對象;

代碼實現主要有兩種方式:餓漢模式和懶漢模式

餓漢模式：類加載的時候對象就已經存在，餓漢式是線程安全的,在類建立的同時就已經建立好一個靜態的對象供系統使用,之後再也不改變。

public class Single {

    private static Single s=new Single();
    private Single(){
        
    }
    public static Single getInstance(){
        return s;
    }
}

懶漢模式：類加載的時候對象還不存在，就是所謂的延遲加載方式，須要時再進行建立，懶漢式若在建立實例對象時不加上synchronized則會致使對對象的訪問不是線程安全的

public class Single {

    private static Single single = null;

    private Single() {

    }

    public static Single getInstance() {
        if (single == null) {
            single = new Single();
        }
        return single;
    }
}

下面咱們解釋一下，懶漢式的線程不安全性，一般狀況下，咱們建議寫餓漢式，由於是線程安全的。
當多線程訪問懶漢式時，由於懶漢式的方法內對共性數據進行多條語句的操做。

 

兩個線程，線程一和線程二同時調用了getInstance方法，當線程1執行了if判斷,single爲空，還沒來得及執行single =new Single()建立對象，這個時候線程2就來了，它也進行if判斷，single依然爲空，則建立Single對象，此時，兩個線程就會建立兩個對象，違背咱們單例模式的初衷，如何解決呢?

出現線程安全的問題，爲了解決這種問題，加入同步機制(不熟悉同步機制的請自行百度吧):靜態同步函數的鎖是類的字節碼文件對象

　　

             

 這樣一種設計能夠保證只產生一個實例，而且只會在初始化的時候加同步鎖，看似精妙絕倫，但卻會引起另外一個問題，這個問題由指令重排序引發。(這一部分來自：http://blog.csdn.net/zhangzeyuaaa/article/details/42673245)

指令重排序是爲了優化指令，提升程序運行效率。指令重排序包括編譯器重排序和運行時重排序。JVM規範規定，指令重排序能夠在不影響單線程程序執行結果前提下進行。例如 instance = new Singleton() 可分解爲以下僞代碼：

memory = allocate();   //1：分配對象的內存空間
ctorInstance(memory);  //2：初始化對象
instance = memory;     //3：設置instance指向剛分配的內存地址

可是通過重排序後以下：

memory = allocate();   //1：分配對象的內存空間
instance = memory;     //3：設置instance指向剛分配的內存地址
                       //注意，此時對象尚未被初始化！
ctorInstance(memory);  //2：初始化對象

將第2步和第3步調換順序，在單線程狀況下不會影響程序執行的結果，可是在多線程狀況下就不同了。線程A執行了instance = memory（這對另外一個線程B來講是可見的），此時線程B執行外層 if (instance == null)，發現instance不爲空，隨即返回，可是獲得的倒是未被徹底初始化的實例，在使用的時候一定會有風險，這正是雙重檢查鎖定的問題所在！

在JDK1.5以後，可使用volatile變量禁止指令重排序：

代碼實現：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
    }

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

volatile的另外一個語義是保證變量修改的可見性。

好，到這裏，就真正的把單例模式介紹完了，在此呢再總結一下單例類須要注意的幾點：

1、單例模式是用來實如今整個程序中只有一個實例的。

2、單例類的構造函數必須爲私有，同時單例類必須提供一個全局訪問點。

3、單例模式在多線程下的同步問題和性能問題的解決。

4、懶漢式和餓漢式單例類。

---

本文爲博主原創文章，轉載請註明出處：http://www.cnblogs.com/ysw-go/一、本博客的原創原創文章，都是本人平時學習所作的筆記，若有錯誤，歡迎指正。二、若有侵犯您的知識產權和版權問題，請通知本人，本人會即時作出處理文章。三、本博客的目的是知識交流所用，轉載自其它博客或網站，做爲本身的參考資料的，感謝這些文章的原創人員