一. 什麼是單例模式
因程序需要，有時我們隻需要某個類同時保留一個對象，不希望有更多對象，此時，我們則應考慮單例模式的設計。
二. 單例模式的特點
1、單例模式隻能有一個執行個體。
2、單例類必須建立自己的唯一執行個體。
3、單例類必須向其他對象提供這一執行個體。
三. 單例模式VS靜态類
在知道了什麼是單例模式後，我想你一定會想到靜态類，“既然隻使用一個對象，為何不幹脆使用靜态類？”，這裡我會将單例模式和靜态類進行一個比較。
1、單例可以繼承和被繼承，方法可以被override，而靜态方法不可以。
2、靜态方法中産生的對象會在執行後被釋放，進而被GC清理，不會一直存在于記憶體中。
3、靜态類會在第一次運作時初始化，單例模式可以有其他的選擇，即可以延遲加載。
4、基于2， 3條，由于單例對象往往存在于DAO層（例如sessionFactory），如果反複的初始化和釋放，則會占用很多資源，而使用單例模式将其常駐于記憶體可以更加節約資源。
5、靜态方法有更高的通路效率。
6、單例模式很容易被測試。
幾個關于靜态類的誤解：
誤解一：靜态方法常駐記憶體而執行個體方法不是。
實際上，特殊編寫的執行個體方法可以常駐記憶體，而靜态方法需要不斷初始化和釋放。
誤解二：靜态方法在堆(heap)上，執行個體方法在棧(stack)上。
實際上，都是加載到特殊的不可寫的代碼記憶體區域中。
靜态類和單例模式情景的選擇：
情景一：不需要維持任何狀态，僅僅用于全局通路，此時更适合使用靜态類。
情景二：需要維持一些特定的狀态，此時更适合使用單例模式。
四. 單例模式的實作
- 懶漢模式（線程不安全）
public class SingletonDemo {
private static SingletonDemo instance;
private SingletonDemo(){
}
public static SingletonDemo getInstance(){
if(instance==null){
instance=new SingletonDemo();
}
return instance;
}
} 如上，通過提供一個靜态的對象instance，利用private權限的構造方法和getInstance()方法來給予通路者一個單例。
缺點是，沒有考慮到線程安全，可能存在多個通路者同時通路，并同時構造了多個對象的問題。之是以叫做懶漢模式，主要是因為此種方法可以非常明顯的lazy loading。
針對懶漢模式線程不安全的問題，我們自然想到了，在getInstance()方法前加鎖，于是就有了第二種實作。
- 線程安全的懶漢模式（線程安全）
public class SingletonDemo {
private static SingletonDemo instance;
private SingletonDemo(){
}
public static synchronized SingletonDemo getInstance(){
if(instance==null){
instance=new SingletonDemo();
}
return instance;
}
} 然而并發其實是一種特殊情況，大多時候這個鎖占用的額外資源都浪費了，這種打更新檔方式寫出來的結構效率很低。
- 餓漢模式（線程安全）
public class SingletonDemo {
private static SingletonDemo instance=new SingletonDemo();
private SingletonDemo(){
}
public static SingletonDemo getInstance(){
return instance;
}
} 直接在運作這個類的時候進行一次loading，之後直接通路。顯然，這種方法沒有起到lazy loading的效果，考慮到前面提到的和靜态類的對比，這種方法隻比靜态類多了一個記憶體常駐而已。
- 靜态類内部加載（線程安全）
public class SingletonDemo {
private static class SingletonHolder{
private static SingletonDemo instance=new SingletonDemo();
}
private SingletonDemo(){
System.out.println("Singleton has loaded");
}
public static SingletonDemo getInstance(){
return SingletonHolder.instance;
}
} 使用内部類的好處是，靜态内部類不會在單例加載時就加載，而是在調用getInstance()方法時才進行加載，達到了類似懶漢模式的效果，而這種方法又是線程安全的。
- 枚舉方法（線程安全）
enum SingletonDemo{
INSTANCE;
public void otherMethods(){
System.out.println("Something");
}
}
Effective Java作者Josh Bloch 提倡的方式，在我看來簡直是來自神的寫法。解決了以下三個問題：
(1)自由串行化。
(2)保證隻有一個執行個體。
(3)線程安全。
如果我們想調用它的方法時，僅需要以下操作：
public class Hello {
public static void main(String[] args){
SingletonDemo.INSTANCE.otherMethods();
}
}
這種充滿美感的代碼真的已經終結了其他一切實作方法了。
Josh Bloch 對這個方法的評價：
這種寫法在功能上與共有域方法相近，但是它更簡潔，無償地提供了串行化機制，絕對防止對此執行個體化，即使是在面對複雜的串行化或者反射攻擊的時候。雖然這中方法還沒有廣泛采用，但是單元素的枚舉類型已經成為實作Singleton的最佳方法。
枚舉單例這種方法問世以來，許多分析文章都稱它是實作單例的最完美方法——寫法超級簡單，而且又能解決大部分的問題。
不過我個人認為這種方法雖然很優秀，但是它仍然不是完美的——比如，在需要繼承的場景，它就不适用了。
- 雙重校驗鎖法（通常線程安全，低機率不安全）
public class SingletonDemo {
private static SingletonDemo instance;
private SingletonDemo(){
System.out.println("Singleton has loaded");
}
public static SingletonDemo getInstance(){
if(instance==null){
synchronized (SingletonDemo.class){
if(instance==null){
instance=new SingletonDemo();
}
}
}
return instance;
}
} 接下來我解釋一下在并發時，雙重校驗鎖法會有怎樣的情景：
STEP 1. 線程A通路getInstance()方法，因為單例還沒有執行個體化，是以進入了鎖定塊。
STEP 2. 線程B通路getInstance()方法，因為單例還沒有執行個體化，得以通路接下來代碼塊，而接下來代碼塊已經被線程1鎖定。
STEP 3. 線程A進入下一判斷，因為單例還沒有執行個體化，是以進行單例執行個體化，成功執行個體化後退出代碼塊，解除鎖定。
STEP 4. 線程B進入接下來代碼塊，鎖定線程，進入下一判斷，因為已經執行個體化，退出代碼塊，解除鎖定。
STEP 5. 線程A擷取到了單例執行個體并傳回，線程B沒有擷取到單例并傳回Null。
理論上雙重校驗鎖法是線程安全的，并且，這種方法實作了lazyloading。
- 第七種終極版 （volatile）
對于6中Double-Check這種可能出現的問題（當然這種機率已經非常小了，但畢竟還是有的嘛~），解決方案是：隻需要給instance的聲明加上volatile關鍵字即可，volatile版本如下：
public class Singleton{
private volatile static Singleton singleton = null;
private Singleton() { }
public static Singleton getInstance() {
if (singleton== null) {
synchronized (Singleton.class) {
if (singleton== null) {
singleton= new Singleton();
}
}
}
return singleton;
}
} volatile關鍵字的一個作用是禁止指令重排，把instance聲明為volatile之後，對它的寫操作就會有一個記憶體屏障（什麼是記憶體屏障？），這樣，在它的指派完成之前，就不用會調用讀操作。
注意：volatile阻止的不singleton = newSingleton()這句話内部[1-2-3]的指令重排，而是保證了在一個寫操作（[1-2-3]）完成之前，不會調用讀操作（if (instance == null)）。
也就徹底防止了6中的問題發生。
- 使用ThreadLocal實作單例模式（線程安全）
public class Singleton {
private static final ThreadLocal<Singleton> tlSingleton =
new ThreadLocal<Singleton>() {
@Override
protected Singleton initialValue() {
return new Singleton();
}
}; /\*\*
\* Get the focus finder for this thread.
\*/
public static Singleton getInstance() {
return tlSingleton.get();
}
// enforce thread local access
private Singleton() {}
} ThreadLocal會為每一個線程提供一個獨立的變量副本，進而隔離了多個線程對資料的通路沖突。對于多線程資源共享的問題，同步機制采用了“以時間換空間”的方式，而ThreadLocal采用了“以空間換時間”的方式。前者僅提供一份變量，讓不同的線程排隊通路，而後者為每一個線程都提供了一份變量，是以可以同時通路而互不影響。
- 使用CAS鎖實作（線程安全）
/\*\*
\* 更加優美的Singleton, 線程安全的
\*/
public class Singleton {
/\*\* 利用AtomicReference \*/
private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>();
/\*\*
\* 私有化
\*/
private Singleton(){
}
/\*\*
\* 用CAS確定線程安全
\*/
public static final Singleton getInstance(){
for (;;) {
Singleton current = INSTANCE.get();
if (current != null) {
return current;
}
current = new Singleton();
if (INSTANCE.compareAndSet(null, current)) {
return current;
}
}
}
public static void main(String[] args) {
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2);
}
} ![Java String.format方法的簡單使用[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)