閻宏博士的《JAVA與模式》定義的單例模式為：
作為對象的創建模式，單例模式確保某一個類只有一個實例，而且自行實例化并向整個系統提供這個實例。這個類稱為單例類。
按照此描述，單例模式屬于設計模式中的創建模式，其特點是： 只能有一個實例；必須自己創建自己的唯一實例；必須給所有其他對象提供這一實例。
單例模式常見實現方式：
1、餓漢式
public class EagerSingleton {
private static EagerSingleton instance = new EagerSingleton();
/**
* 默認私有構造方法
*/
private EagerSingleton(){}
/**
* 靜態公共方法，取得實例的唯一入口
*/
public static EagerSingleton getInstance(){
return instance;
}
}
采用這種方式，在類EagerSingleton 被加載時，靜態變量instance會被初始化，此時類的默認私有構造方法被調用，進而創建了單例實例。
餓漢式是典型的空間換時間，當類裝載的時候就會創建類的實例，不管用或者不用，什么時候用，都會先創建出來，然后每次調用的時候，就不需要再判斷，節省了運行時間。
2、懶漢式
public class LazySingleton {
private static LazySingleton instance = null;
/**
* 默認私有構造方法
*/
private LazySingleton(){}
/**
* 靜態公共方法，取得實例的唯一入口（注意：synchronized關鍵字）
*/
public static synchronized LazySingleton getInstance(){
if(instance == null){
instance = new LazySingleton();
}
return instance;
}
}
這種方式實現時，要注意getInstance() 需要同步，以應對多線程競爭。
懶漢式是典型的時間換空間。每次獲取實例都會進行判斷，看是否需要創建實例，會耗費判斷時間。當然，如果一直沒有人使用的話，就不會創建實例，則節約內存空間。
由于懶漢式的實現是線程安全的，需要同步，并且每次都要判空，這樣會降低整個訪問的速度。那么有沒有更好的方式實現呢？
3、雙重檢查加鎖（double check lock）
所謂“雙重檢查加鎖”機制，指的是：并不是每次進入getInstance方法都需要同步，而是先不同步，進入方法后，先檢查實例是否存在，如果不存在才進行下面的同步塊，這是第一重檢查，進入同步塊過后，再次檢查實例是否存在，如果不存在，就在同步的情況下創建一個實例，這是第二重檢查。這樣一來，就只需要同步一次了，從而減少了多次在同步情況下進行判斷所浪費的時間。
“雙重檢查加鎖”機制的實現會使用關鍵字volatile，它的意思是：被volatile修飾的變量的值，將不會被本地線程緩存，所有對該變量的讀寫都是直接操作共享內存，從而確保多個線程能正確的處理該變量。
注意：在java1.4及以前版本中，很多JVM對于volatile關鍵字的實現的問題，會導致“雙重檢查加鎖”的失敗，因此“雙重檢查加鎖”機制只只能用在java5及以上的版本。
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關鍵字可能會屏蔽掉虛擬機中一些必要的代碼優化，所以運行效率并不是很高。因此一般建議，沒有特別的需要，不要使用。也就是說，雖然可以使用“雙重檢查加鎖”機制來實現線程安全的單例，但并不建議大量采用，可以根據情況來選用。
根據上面的分析，常見的兩種單例實現方式都存在小小的缺陷，那么有沒有一種方案，既能實現延遲加載，又能實現線程安全呢？
4、Lazy initialization holder class模式
這個模式綜合使用了Java的類級內部類和多線程缺省同步鎖的知識，很巧妙地同時實現了延遲加載和線程安全。
1）.相應的基礎知識
簡單點說，類級內部類指的是，有static修飾的成員式內部類。如果沒有static修飾的成員式內部類被稱為對象級內部類。
類級內部類相當于其外部類的static成分，它的對象與外部類對象間不存在依賴關系，因此可直接創建。而對象級內部類的實例，是綁定在外部對象實例中的。
類級內部類中，可以定義靜態的方法。在靜態方法中只能夠引用外部類中的靜態成員方法或者成員變量。
類級內部類相當于其外部類的成員，只有在第一次被使用的時候才被會裝載。
大家都知道，在多線程開發中，為了解決并發問題，主要是通過使用synchronized來加互斥鎖進行同步控制。但是在某些情況中，JVM已經隱含地為您執行了同步，這些情況下就不用自己再來進行同步控制了。這些情況包括：
1.由靜態初始化器（在靜態字段上或static{}塊中的初始化器）初始化數據時
2.訪問final字段時
3.在創建線程之前創建對象時
4.線程可以看見它將要處理的對象時
2）.解決方案的思路
要想很簡單地實現線程安全，可以采用靜態初始化器的方式，它可以由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方法第一次被調用的時候，它第一次讀取SingletonHolder.instance，導致SingletonHolder類得到初始化；而這個類在裝載并被初始化的時候，會初始化它的靜態域，從而創建Singleton的實例，由于是靜態的域，因此只會在虛擬機裝載類的時候初始化一次，并由虛擬機來保證它的線程安全性。
這個模式的優勢在于，getInstance方法并沒有被同步，并且只是執行一個域的訪問，因此延遲初始化并沒有增加任何訪問成本。
5、單例和枚舉（還沒實際用過）
按照《高效Java 第二版》中的說法：單元素的枚舉類型已經成為實現Singleton的最佳方法。用枚舉來實現單例非常簡單，只需要編寫一個包含單個元素的枚舉類型即可。
public enum Singleton {
/**
* 定義一個枚舉的元素，它就代表了Singleton的一個實例。
*/
uniqueInstance;
/**
* 單例可以有自己的操作
*/
public void singletonOperation(){
//功能處理
}
}
使用枚舉來實現單實例控制會更加簡潔，而且無償地提供了序列化機制，并由JVM從根本上提供保障，絕對防止多次實例化，是更簡潔、高效、安全的實現單例的方式。