一.定義：
確保某一個類只有一個例項，而且自行例項並向整個系統提供這個例項

二.使用場景：
避免產生過多的物件消耗過多的資源，或者某種型別的物件只應該有且只有一個。例如，建立一個物件需要消耗的資源過多，如訪問資料庫或者IO 資源。

三.實現單例模式的關鍵點：
1.私有化構造方法
2.通過靜態方法或列舉返回單例類物件
3.確保單例類的物件有且只有一個，尤其在多執行緒下
4.確保單例物件在反序列化時不會重新構建物件

四.實現方式

1.Double Check Lock(DCL)實現模式

public class SingleInstance
{
    private static
 
 volatile SingleInstance sInstance = null;

    private SingleInstance()
    {
    }

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

那麼這裡為啥判空兩次呢？
第一次判空是為了避免不必要的同步，第二次判空則是為了在null的情況下建立例項。
分析：sInstance=new SingleInstance()語句並不是一個原子操作，程式碼會被編譯成多條編譯指令，這裡大致做了三件事情
（1）給SingleInstance的例項分配記憶體
（2）呼叫SingleInstance的構造方法SingleInstance（），初始化成員欄位
（3）將sInstance的物件指向分配的記憶體空間（此時sInstance就不是null了）

但是，由於java編譯器允許處理器亂序執行，以及jdk1.5之前的JMM（Java Memory Model）的Cache，暫存器到主存回寫順序的規定，上面的（2）（3）的順序是不確定的，也就是說執行順序可能是1-3-2，1-2-3，如果是前者，（3）執行完（2）還未執行，切換到B執行緒，這時候sInstance已經是非空的了，B這時候直接取走sInstance，使用的時候就會出錯，這就是DCL失效的原因。
jdk1.5之後，sun公司意識到這個問題，調整了JVM，具體化了volatile關鍵字，可以保證sInstance每次都是從主存中取。

2.靜態內部類單例模式：

public class SingleInstance{
    private SingleInstance(){}
    public static SingleInstance getInstance(){
        return SingleInstanceHolder.sInstance;
    }
    private static class SingleInstanceHolder{
        private static final SingleInstance sInstance=new SingleInstance();
    }
}

第一次載入SingleInstance 並不是初始化sInstance，只有在第一次呼叫getInstance方法才會導致sInstance的初始化，這種方式能確保執行緒安全，單例物件唯一性。

3.列舉型別

public enum SingleInstance{
    INSTANCE;
    public void doSomething(){`這裡寫程式碼片`

    }
}

執行緒安全，任何時候都是單一例項。
在上述的幾種實現方式中，在反序列化的情況下他們會出現重新建立物件。為什麼？
序列化可以將一個單例的例項物件寫到磁碟，然後在讀出來，從而有效的獲得一個例項。即使構造方法是私有的，反序列化仍可以通過一個特殊途徑建立一個新的例項，，相當於呼叫構造方法，反序列化提供了一個特別的鉤子函式，可以控制物件的反序列化。在上述的示例中，如果杜絕物件在反序列化時重新生成物件，必須加入readResolve函式。列舉則不會出現這種問題

public class SingleInstance implements Serializable
{
    private static final long serialVersionUID = 0L;

    private static volatile SingleInstance sInstance = null;

    private SingleInstance()
    {
    }

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

    private Object readResolve() throws ObjectStreamException
    {
        return sInstance;
    }
}

三點注意：
1.單例中如果需要Context，最好傳入ApplicationContext，否則很容易發生記憶體洩漏。
2.可序列化的欄位型別不是Java內建模型，這個欄位也要實現Serializable.
3.如果你調整了可序列化類的內部結構，沒有修改serialVersionUID，就會丟擲異常，最好的方案是將serialVersionUID設定為0L，這樣即使改 了類的內部結構，不會丟擲異常，只是修改的欄位為0或者null。

四.使用容器類實現單例模式

public class SingleInstanceManager
{
    private static Map<String, Object> sObjectMap = new HashMap<>();

    private SingleInstanceManager()
    {
    }

    public static void registerService(String key, Object instance)
    {
        if (!sObjectMap.containsKey(key))
        {
            sObjectMap.put(key, instance);
        }
    }

    public static Object getService(String key)
    {
        return sObjectMap.get(key);
    }
}