定義
一個類只有一個實例，自行實例化并提供給整個系統
基本思路
將該類構造函數私有化，并通過靜態方法獲取一個唯一實例，獲取過程保證線程安全
懶漢式線程不安全寫法
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
假設有A、B線程同時調用getInstance方法，在分水嶺同時執行完判斷后，有CPU時間片切換，假設A線程得到執行權，繼續向下執行，實例化了對象，此時instance不為空，而B線程又做了實例化工作，就會導致實例不唯一。
懶漢式線程安全
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static synchronized Singleton getInstance() {
if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
在getInstance()方法前加上synchronized，使整個方法同步，就可以保證線程安全，避免多實例的問題，但是這樣并不高效，因為在第一次調用getInstance()方法后，instance不為空，之后再調用該方法就要走同步，這樣會消耗不必要的資源。
Double Check Lock(雙重檢驗鎖)
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (null == instance) {
synchronized (Singleton.class) {
if (null == instance) {
instance = new Singleton();
}
}
}
return instance;
}
}
這里為啥要做兩次檢驗呢？我們先來看下，如果去掉第一層檢驗會怎樣
public static Singleton getInstance() {
synchronized (Singleton.class) {
if (null == instance) {
instance = new Singleton();
}
}
return instance;
}
當有兩個線程同時調用getInstance()方法時，由于同步機制的存在，假設此時A線程得到CPU的執行權，走到同步塊中執行，執行了instance = new Singleton()后，退出同步語句塊，此時instance已經不為null了，這時候B線程獲得CPU執行權也進入同步塊，就會被instance == null的判斷擋在外面了。所以就算不要第一層檢驗也是可以實現多線程安全的單例，那為毛還要寫？原來這里涉及到性能問題，上面懶漢式線程安全的寫法也是安全的，但是每次調用都要走同步會影響性能，這里也一樣。我們希望這里的new Singleton()只執行一次，如果少了第一層的判斷，每次有線程進入getInstance()時，均會執行鎖定操作來實現線程同步，這是非常耗費性能的，而多了第一層檢驗，只要第一次instance==null會執行鎖定操作，之后的調用直接return instance就行。
再看如果少了第二層檢驗，其實這就跟第一種懶漢式線程不安全寫法一樣，在多線程并發的情況下不能達到保持單例的效果。
那么雙重檢驗機制是否就能完美解決問題？其實不然，其原因在于instance == new Singleton();這句并非是個原子操作，當JVM執行到這一句時，分別作了如下操作：
- 在堆中為instance 分配內存
- 調用Singleton的構造函數初始化成員變量
- 將instance對象執行分配的內存空間（執行完這步instance就為非null了）
如果上面的操作按1-2-3順序執行，那就沒啥問題，但是由于JVM的即時編譯器中存在指令重排序的優化，上面的操作有可能是1-3-2。這會出現啥情況？
public static Singleton getSingleton() {
if (instance == null) { //p2
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton(); //p1
}
}
}
return instance ;
}
假設線程A此時走到p1處，JVM按照1-3-2的順序實例化instance，才執行完1-3，來不及執行2，線程B獲得了CPU執行權也調用了getInstance()方法，并走到p2處，此時instance不為null，線程B就屁顛屁顛拿著得到的實例回去干活了，但是里頭的成員變量還沒初始化，這就尷尬了，報錯也就理所當然了。
要解決這問題只要把instance設置成volatile，禁止重排序優化，以上面的例子，不管是1-2-2還是1-3-2，讀取必須在操作完全執行完后才能進行。
public class Singleton {
private volatile static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (null == instance) {
synchronized (Singleton.class) {
if (null == instance) {
instance = new Singleton();
}
}
}
return instance;
}
}
然而java5以前的版本使用volatile還是有問題，也不能完全避免重排序。
惡漢式
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}
由于instance被static和final修飾，在該類第一次被加載到內存中時就會對instance實例化，這樣保證了單例。缺點是就算其他地方沒有調用getInstance()方法，也會創建實例。
靜態內部類
public class Singleton {
private Singleton() {
}
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
靜態內部類就比較好的彌補了惡漢式單例不足，也是比較推崇的寫法。
