概念：

　　作為物件的建立模式，單例模式確保某一個類只有一個例項，而且自行例項化，並向整個系統提供這個例項。

特點：

　　1.單例類只能有一個例項

　　2.單例類必須建立自己的唯一例項

　　3.單例類必須給其他所有物件提供這一例項。

餓漢式單例類

public class EagerSingleton {
    private static EagerSingleton instance = new EagerSingleton();
    /**
     * 私有預設構造子
     */
    private EagerSingleton(){}
    /**
     * 靜態工廠方法
     
 
*/
    public static EagerSingleton getInstance(){
        return instance;
    }
}

由於選用的是靜態資源，在類載入的時候，靜態變數instance就會被初始化，類的唯一變數也在這時候建立了出來。

餓漢式，顧名思義，急於建立物件，在類載入的時候就完成了物件的建立。

餓漢式是一種採用“空間換取時間”，當類裝載的時候就會建立類的例項，不管你用不用，先建立，呼叫的時候，無需判斷直接使用，節約了時間。

懶漢式單例

public class LazySingleton {
    private static LazySingleton instance = null
 
;
    /**
     * 私有預設構造子
     */
    private LazySingleton(){}
    /**
     * 靜態工廠方法
     */
    public static synchronized LazySingleton getInstance(){
        if(instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

只有在真正需要的時候才會去建立，採用的是時間換空間，由於是執行緒安全的，會降低訪問速度。固可使用雙檢鎖的方式進行優化。

雙重檢查加鎖

機制：並不是每次進入getInstance方法都需要同步，而不是先同步，進入方法後，先檢查例項是否存在，如果不存在才進行下面的同步塊，這是第一檢查，進入同步塊後，在檢查例項是否存在，如果不存在，就在同步的情況下建立一個例項，這是第二重檢查，這樣一來就只需要同步一次，減少了多次在同步情況下進行判斷所浪費的時間。

雙檢鎖的關鍵是，使用volatile，它在此處的作用是，該變數將不會被某一個執行緒快取，而是在共享記憶體中，被所有進行讀寫的記憶體共享到，從而保證多個執行緒能夠正確處理該變數。

public class Singleton {
    private volatile static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        //先檢查例項是否存在，如果不存在才進入下面的同步塊
        if(instance == null){
            //同步塊，執行緒安全的建立例項
            synchronized (Singleton.class) {
                //再次檢查例項是否存在，如果不存在才真正的建立例項
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

注：由於volatile關鍵字會遮蔽虛擬機器的一些程式碼優化，所以執行效率並不高，所有其實應該儘量避免使用雙檢鎖的方式來實現單例。

懶載入模式(內部類形式)

什麼是內部類：

　　內部類就是指在類裡面的類，被static修飾的內部類，稱為類級內部類，無static修飾的內部類稱為物件級內部類。

　　類級內部類是外部類的static部分，它的物件與外部類物件間並沒有依賴關係，因此可以直接建立。而物件級內部類的例項，是繫結在外部物件的例項中的。

　　類級內部類中，可以定義靜態方法，在靜態方法中只能夠引用外部類中的靜態成員或者成員變數。

　　類級內部類相當於外部類的成員，只有在第一次被使用的時候才會載入。

多執行緒預設同步鎖的相關知識：

　　在下面操作下，jvm會自動為該操作進行同步，以避免出現併發安全問題。

　　1.由靜態初始化器(在靜態欄位上或static{}塊中的初始化器)初始化資料。

　　2.訪問final欄位時，

　　3.在建立執行緒前建立物件時，

　　4.執行緒可以看見它將要處理的物件時。

綜上的解決思路：

　　採用靜態初始化器的方式通過jvm來保證執行緒的安全性，採用類級內部類的方式實現延遲載入。

public class Singleton {
    
    private Singleton(){}
    /**
     *    類級的內部類，也就是靜態的成員式內部類，該內部類的例項與外部類的例項
     *    沒有繫結關係，而且只有被呼叫到時才會裝載，從而實現了延遲載入。
     */
    private static class SingletonHolder{
        /**
         * 靜態初始化器，由JVM來保證執行緒安全
         */
        private static Singleton instance = new Singleton();
    }
    
    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

　　在getInstance第一次被呼叫時，會讀取內部類的instance，這時，類級內部類完成初始化，從而建立單例，實現了延時載入，由於是靜態成員，只有在類載入的時候才載入一次，且通過jvm的預設方式實現了執行緒安全問題。

單例類列舉：

　　單元素的列舉型別已經成為實現Singleton的最佳方法。用列舉來實現單例非常簡單，只需要編寫一個包含單個元素的列舉型別即可。

public enum Singleton {
    /**
     * 定義一個列舉的元素，它就代表了Singleton的一個例項。
     */
    
    uniqueInstance;
    
    /**
     * 單例可以有自己的操作
     */
    public void singletonOperation(){
        //功能處理
    }
}

　　使用列舉來實現單例項控制會更加簡潔，而且無償地提供了序列化機制，並由JVM從根本上提供保障，絕對防止多次例項化，是更簡潔、高效、安全的實現單例的方式。