單例模式(Singleton Pattern)確保一個類只有一個實例，并且提供一個全局的訪問。

單例模式隨處可見，比如線程池、緩存、對話框、日志對象等，這些時候如果制造出多個實例，程序運行就會出現預期之外的情況。
這里可能有疑問，我用全局靜態變量也能做到一個類只有一個實例，為什么要引入這樣一個設計模式呢？原因其實很簡單，全局靜態變量會造成資源浪費：假設這個類非常消耗資源，程序在運行過程中，不是每一次都用到這個類，那就是極大的浪費。

類圖

類圖不是目的，僅僅幫助理解

[圖片上傳失敗...(image-1fb5c0-1527174223215)]

單例模式的類圖很簡單，只有一個類，有一個代表自己實例的instance變量，還有一個提供全局訪問的靜態方法getInstance()。

以下的代碼和思路是針對Java語言

單例類型

單例模式分為懶漢式和餓漢式，區別在于實例化單例對象的時機。

懶漢式

在懶漢式單例模式實現中，不管單例是否用到，都會實例化一個單例對象。典型的寫法如下：

/**
 * 單例
 * Created by Carlton on 2016/11/21.
 */
class Singleton private constructor()
{
    companion object
    {
        private val instance = Singleton()
        fun instance() = instance
    }
}

因為Kotlin和Java在靜態語法上的不一致，后面的代碼都用Java來實現方便理解

/**
 * 單例模式
 * Created by Carlton on 2016/11/21.
 */
public class Singleton
{
    private Singleton()
    {
        
    }

    private static Singleton instance = new Singleton();
    public static Singleton instance()
    {
        return instance;
    }
}

餓漢式非常簡單，也不會出現資源占用之外的其他問題，就不多說。

飽漢式、常規方法

飽漢式也就是常規實現方式比較復雜，原因是我們用到類實例的時候才會去實例化，這中間會出現各種各樣的情況。

介紹了兩種實現方式，接下來我們實現一個常規的單例模式：

/**
 * 單例模式
 * Created by Carlton on 2016/11/21.
 */
public class Singleton
{
    private Singleton()
    {

    }

    private static Singleton instance = null;
    public static Singleton instance()
    {
        if(instance == null)
        {
            // 1
            instance = new Singleton();
        }
        return instance;
    }
}

在客戶端獲取單例的時候，檢查對象是否是null如果是，則實例化一個，如果不是則直接返回已有的對象，如果在單線程的情況下，確實如此，現在如果，兩個或者兩個以上的線程就有問題了：

• 如果兩個線程都到1這個位置
• 那么現在的情況就是if (instance == null)判斷的時候兩個線程都通過了
• 這個時候instance會實例化兩次，這兩個線程拿到的不是同一個實例

怎么解決這個問題呢？不慌解決，先看看一下雙重驗證和volatile

雙重檢查和volatile

如果加上線程鎖，好像問題就解決了，先看看加線程鎖怎么寫:

/**
 * 單例模式
 * Created by Carlton on 2016/11/21.
 */
public class Singleton
{
    private Singleton()
    {

    }

    private static Singleton instance = null;
    public static Singleton instance()
    {
        if(instance == null)
        {
            // 1
            synchronized (Singleton.class)
            {
                // 2
                if(instance == null)
                { // 3
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

現在看看多線程的情況程序會出現什么問題：

• 如果有兩個線程都到了1
• 因為同步鎖的原因，只有一個線程可以先進入到2
• 當第一個線程進入3實例化一個instance后，第二個線程進入判斷的時候，就不會進入3
  這就是雙重驗證，在C/C++中，這樣做是沒有問題的，但是：雙重檢查對Java語言編譯器不成立！原因在于，Java編譯器中，Singleton類的初始化與instance變量賦值的順序不可預料，如果一個線程在沒有同步化的條件下讀取instance引用，并調用這個對象的方法的話，可能會發現對象的初始化過程還沒有完成，從而造成崩潰。

可能有人會覺得volatile可以解決問題，修改變量申明:

private static volatile Singleton instance = null;

先看看volatile是什么？

volatile變量具有synchronized的可見性特性，但是不具備原子特性。這就是說線程能夠自動發現volatile變量的最新值。volatile變量可用于提供線程安全，但是只能應用于非常有限的一組用例：多個變量之間或者某個變量的當前值與修改后值之間沒有約束。

通過這個描述知道volatile是一個輕量級的線程同步，之前出現的問題在于線程沒有同步化的條件下讀取instance，現在加上volatile問題就解決了。但是：JDK1.5之前，這樣使用雙重檢查還是有問題。

Java中如何正確的實現單例模式

說了這么多，如何才能正確實現單例模式呢？

• 使用餓漢式
• JDK1.5以后使用帶volatile修飾的雙重檢查
• 同步鎖加到方法上：

/**
 * 單例模式
 * Created by Carlton on 2016/11/21.
 */
public class Singleton
{
        private static volatile Singleton instance = null;
        private Singleton()
        {
        }
        public static synchronized Singleton instance()
        {
            if (instance == null)
            {
                instance = new Singleton();
            }
        return instance;
        }
}

多說幾句，如果把同步鎖加到方法上面，代表這個方法同一時間只有一個線程能夠進入方法，這個時候后面的線程進入就會正常的直接返回instance實例。

總結

單例模式在思路上是很簡單的模式，也就不提供例子，單例模式還有很多單例模式的變種，但是核心沒變：一個類只有一個實例；這個實例由自己來實例化；單例模式沒有提供公共的構造函數，所以其他類不能對其實例化。需要注意的是，這個模式的復雜點在于實現方式，如何才能保證在各種情況下只有一個類實例才是關鍵點。

??查看更多??

不登高山，不知天之高也；不臨深溪，不知地之厚也
感謝指點、交流、喜歡