一. 什麼是單例模式

因程式需要，有時我們只需要某個類同時保留一個物件，不希望有更多物件，此時，我們則應考慮單例模式的設計。

二. 單例模式的特點

1. 單例模式只能有一個例項。

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

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

三. 單例模式VS靜態類

在知道了什麼是單例模式後，我想你一定會想到靜態類，“既然只使用一個物件，為何不乾脆使用靜態類？”，這裡我會將單例模式和靜態類進行一個比較。

1. 單例可以繼承和被繼承，方法可以被override，而靜態方法不可以。

2. 靜態方法中產生的物件會在執行後被釋放，進而被GC清理，不會一直存在於記憶體中。

3. 靜態類會在第一次執行時初始化，單例模式可以有其他的選擇，即可以延遲載入。

4. 基於2， 3條，由於單例物件往往存在於DAO層（例如sessionFactory），如果反覆的初始化和釋放，則會佔用很多資源，而使用單例模式將其常駐於記憶體可以更加節約資源。

5. 靜態方法有更高的訪問效率。

6. 單例模式很容易被測試。

幾個關於靜態類的誤解：

誤解一：靜態方法常駐記憶體而例項方法不是。

實際上，特殊編寫的例項方法可以常駐記憶體，而靜態方法需要不斷初始化和釋放。

誤解二：靜態方法在堆(heap)上，例項方法在棧(stack)上。

實際上，都是載入到特殊的不可寫的程式碼記憶體區域中。

靜態類和單例模式情景的選擇：

情景一：不需要維持任何狀態，僅僅用於全域性訪問，此時更適合使用靜態類。

情景二：需要維持一些特定的狀態，此時更適合使用單例模式。

四. 單例模式的實現

1. 懶漢模式（ 執行緒不安全）

//java學習交流:737251827  進入可領取學習資源及對十年開發經驗大佬提問，免費解答！


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()方法前加鎖，於是就有了第二種實現。

1. 執行緒安全的懶漢模式（ 執行緒安全）

public 
class 
SingletonDemo 
{

    
private 
static SingletonDemo instance
;

    
private 
SingletonDemo
(
)
{



    
}

    
public 
static synchronized SingletonDemo 
getInstance
(
)
{

        
if
(instance
==
null
)
{

            instance
=
new 
SingletonDemo
(
)
;

        
}

        
return instance
;

    
}


}

然而併發其實是一種特殊情況，大多時候這個鎖佔用的額外資源都浪費了，這種打補丁方式寫出來的結構效率很低。

1. 餓漢模式（ 執行緒安全）

public 
class 
SingletonDemo 
{

    
private 
static SingletonDemo instance
=
new 
SingletonDemo
(
)
;

    
private 
SingletonDemo
(
)
{



    
}

    
public 
static SingletonDemo 
getInstance
(
)
{

        
return instance
;

    
}


}

直接在執行這個類的時候進行一次loading，之後直接訪問。顯然，這種方法沒有起到lazy loading的效果，考慮到前面提到的和靜態類的對比，這種方法只比靜態類多了一個記憶體常駐而已。

1. 靜態類內部載入（ 執行緒安全）

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
;

    
}


}

1. 使用內部類的好處是，靜態內部類不會在單例載入時就載入，而是在呼叫getInstance()方法時才進行載入，達到了類似懶漢模式的效果，而這種方法又是執行緒安全的。
   

2. 列舉方法（ 執行緒安全）

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的最佳方法。列舉單例這種方法問世以來，許多分析文章都稱它是實現單例的最完美方法——寫法超級簡單，而且又能解決大部分的問題。不過我個人認為這種方法雖然很優秀，但是它仍然不是完美的——比如，在需要繼承的場景，它就不適用了。

1. 雙重校驗鎖法（ 通常執行緒安全，低概率不安全）

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。

1. 第七種終極版 （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中的問題發生。

1. 使用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採用了“以空間換時間”的方式。前者僅提供一份變數，讓不同的執行緒排隊訪問，而後者為每一個執行緒都提供了一份變數，因此可以同時訪問而互不影響。

1. 使用CAS鎖實現（ 執行緒安全）

/**

 * 更加優美的Singleton, 執行緒安全的

 *java學習交流:737251827  進入可領取學習資源及對十年開發經驗大佬提問，免費解答！

 */


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
)
;

 
}


}