單例模式：是一種常用的軟件設計模式，在它的核心結構中值包含一個被稱為單例的特殊類。一個類只有一個實例，即一個類只有一個對象實例。

　　對於系統中的某些類來說，只有一個實例很重要，例如，一個系統中可以存在多個打印任務，但是只能有一個正在工作的任務；售票時，一共有100張票，可有有多個窗口同時售票，但需要保證不要超售（這裏的票數余量就是單例，售票涉及到多線程）。如果不是用機制對窗口對象進行唯一化將彈出多個窗口，如果這些窗口顯示的都是相同的內容，重復創建就會浪費資源。

　　應用場景（來源：《大話設計模式》）：

　　　　需求：在前端創建工具箱窗口，工具箱要麽不出現，出現也只出現一個

　　　　遇到問題：每次點擊菜單都會重復創建“工具箱”窗口。

　　　　解決方案一：使用if語句，在每次創建對象的時候首先進行判斷是否為null，如果為null再創建對象。

　　　　需求：如果在5個地方需要實例出工具箱窗體

　　　　遇到問題：這個小bug需要改動5個地方，並且代碼重復，代碼利用率低

　　　　解決方案二：利用單例模式，保證一個類只有一個實例，並提供一個訪問它的全局訪問點。

　　通過以下幾種方式，我們會發現，所有的單例模式都是使用靜態方法進行創建的，所以單例對象在內存中靜態共享區中存儲。（可參考：https://zhidao.baidu.com/question/2206072272164938188.html）

　　 單例模式可以分為懶漢式和餓漢式

　　　　懶漢式單例模式：在類加載時不初始化。

　　　　餓漢式單例模式：在類加載時就完成了初始化，所以類加載比較慢，但獲取對象的速度快。

　　第一種（懶漢，線程不安全）:

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

這種寫法lazy loading很明顯，但是致命的是在多線程不能正常工作。　

第二種（懶漢，線程安全）：

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

這種寫法在getInstance()方法中加入了synchronized鎖。能夠在多線程中很好的工作，而且看起來它也具備很好的lazy loading，但是效率很低（因為鎖），並且大多數情況下不需要同步。

第三種（餓漢）：

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

這種方式基於classloder機制避免了多線程的同步問題，不過，instance在類裝載時就實例化，這時候初始化instance顯然沒有達到lazy loading的效果。

　 第四種（餓漢，變種）：

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

表面上看起來差別挺大，其實更第三種方式差不多，都是在類初始化即實例化instance

第五種（靜態內部類）：

public class SingletonDemo5 {
    private static class SingletonHolder{
        private static final SingletonDemo5 instance = new SingletonDemo5();
    }
    private SingletonDemo5(){}
    public static final SingletonDemo5 getInsatance(){
        return SingletonHolder.instance;
    }
}

這種方式同樣利用了classloder的機制來保證初始化instance時只有一個線程，它跟第三種和第四種方式不同的是（很細微的差別）：第三種和第四種方式是只要Singleton類被裝載了，那麽instance就會被實例化（沒有達到lazy loading效果），而這種方式是Singleton類被裝載了，instance不一定被初始化。因為SingletonHolder類沒有被主動使用，只有顯示通過調用getInstance方法時，才會顯示裝載SingletonHolder類，從而實例化instance。想象一下，如果實例化instance很消耗資源，我想讓他延遲加載，另外一方面，我不希望在Singleton類加載時就實例化，因為我不能確保Singleton類還可能在其他的地方被主動使用從而被加載，那麽這個時候實例化instance顯然是不合適的。這個時候，這種方式相比第三和第四種方法就顯得更合理。

第六種（枚舉）：

public enum SingletonDemo6 {
    instance;
    public void whateverMethod(){
    }
}

這種方式是Effective Java作者Josh Bloch 提倡的方式，它不僅能避免多線程同步問題，而且還能防止反序列化重新創建新的對象，可謂是很堅強的壁壘啊，不過，個人認為由於1.5中才加入enum特性，用這種方式寫不免讓人感覺生疏，在實際工作中，我也很少看見有人這麽寫過。

第七種（雙重校驗鎖）：

public class SingletonDemo7 {
    private volatile static SingletonDemo7 singletonDemo7;
    private SingletonDemo7(){}
    public static SingletonDemo7 getSingletonDemo7(){
        if (singletonDemo7 == null) {
            synchronized (SingletonDemo7.class) {
                if (singletonDemo7 == null) {
                    singletonDemo7 = new SingletonDemo7();
                }
            }
        }
        return singletonDemo7;
    }
}

這個是第二種方式的升級版，俗稱雙重檢查鎖定，詳細介紹請查看：http://www.ibm.com/developerworks/cn/java/j-dcl.html

在JDK1.5之後，雙重檢查鎖定才能夠正常達到單例效果。

多線程時的單例，多線程的程序中，多個線程同時訪問該單例，會有可能創建多個實例。這個時候就需要用“鎖”將它鎖起來。包括鎖、死鎖、鎖之間的通信，關於多線程這部分待後續詳解！

參考：http://cantellow.iteye.com/blog/838473

常見的幾種單例模式