作者：小小木的博客
www.cnblogs.com/wyc1994666/p/11394755.html
1. 單例模式常見問題
為什么要有單例模式
單例模式是一種設計模式，它限制了實體化一個物件的行為，始終至多只有一個實體，當只需要一個物件來協調整個系統的操作時，這種模式就非常有用.它描述了如何解決重復出現的設計問題，
比如我們專案中的配置工具類,日志工具類等等，
如何設計單例模式 ?
1.單例類如何控制其實體化
2.如何確保只有一個實體
通過一下措施解決這些問題：
private建構式,類的實體話不對外開放,由自己內部來完成這個操作,確保永遠不會從類外部實體化類,避免外部隨意new出來新的實體，
該實體通常存盤為私有靜態變數，提供一個靜態方法，回傳對實體的參考，如果是在多執行緒環境下則用鎖或者內部類來解決執行緒安全性問題，
2. 單例類有哪些特點 ?
私有建構式
它將阻止從類外部實體化新物件
它應該只有一個實體
這是通過在類中提供實體來方法完成的,阻止外部類或子類來創建實體，這是通過在java中使建構式私有來完成的，這樣任何類都不能訪問建構式，因此無法實體化它，
單實體應該是全域可訪問的
單例類的實體應該是全域可訪問的，以便每個類都可以使用它，在Java中，它是通過使實體的訪問說明符為public來完成的，
節省記憶體,減少GC
因為是全域至多只有一個實體，避免了到處new物件,造成浪費記憶體,以及GC，有了單例模式可以避免這些問題，
3. 單例模式8種寫法
下面由我給大家介紹8種單例模式的寫法,各有千秋,存在即合理，通過自己的使用場景選一款使用即可，我們選擇單例模式時的挑選標準或者說評估一種單例模式寫法的優劣時通常會根據一下兩種因素來衡量:
1.在多執行緒環境下行為是否執行緒安全
2.餓漢以及懶漢
3.編碼是否優雅(理解起來是否比較直觀)
1. 餓漢式執行緒安全的
public class SingleTon{
private static final SingleTon INSTANCE = new SingleTon();
private SingleTon(){ }
public static SingleTon getInstance(){
return INSTANCE;
}
public static void main(String[] args) {
SingleTon instance1 = SingleTon.getInstance();
SingleTon instance2 = SingleTon.getInstance();
System.out.println(instance1 == instance2);
}
}
這種寫法是非常簡單實用的，值得推薦，唯一缺點就是懶漢式的，也就是說不管是否需要用到這個方法，當類加載的時候都會生成一個物件，
除此之外，這種寫法是執行緒安全的，類加載到記憶體后，就實體化一個單例，JVM保證執行緒安全，關注公眾號Java技術堆疊回復設計模式獲取我整理的系列Java設計模式教程，
2. 餓漢式執行緒安全(變種寫法)，
public class SingleTon{
private static final SingleTon INSTANCE ;
static {
INSTANCE = new SingleTon();
}
private SingleTon(){}
public static SingleTon getInstance(){
return INSTANCE;
}
public static void main(String[] args) {
SingleTon instance1 = SingleTon.getInstance();
SingleTon instance2 = SingleTon.getInstance();
System.out.println(instance1 == instance2);
}
}
3. 懶漢式執行緒不安全，
public class SingleTon{
private static SingleTon instance ;
private SingleTon(){}
public static SingleTon getInstance(){
if(instance == null){
instance = new SingleTon();
}
return instance;
}
public static void main(String[] args) {
SingleTon instance1 = SingleTon.getInstance();
SingleTon instance2 = SingleTon.getInstance();
System.out.println(instance1 == instance2);
// 通過開啟100個執行緒 比較是否是相同物件
for(int i=0;i<100;i++){
new Thread(()->
System.out.println(SingleTon.getInstance().hashCode())
).start();
}
}
}
這種寫法雖然達到了按需初始化的目的，但卻帶來執行緒不安全的問題，至于為什么在并發情況下上述的例子是不安全的呢 ?
// 通過開啟100個執行緒 比較是否是相同物件
for(int i=0;i<100;i++){
new Thread(()->
System.out.println(SingleTon.getInstance().hashCode())
).start();
}
為了使效果更直觀一點我們對getInstance 方法稍做修改,每個執行緒進入之后休眠一毫秒，這樣做的目的是為了每個執行緒都盡可能獲得cpu時間片去執行，代碼如下
public static SingleTon getInstance(){
if(instance == null){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
instance = new SingleTon();
}
return instance;
}
執行結果如下
上述的單例寫法，我們是可以創造出多個實體的，至于為什么在這里要稍微解釋一下,這里涉及了同步問題
造成執行緒不安全的原因：
當并發訪問的時候，第一個呼叫getInstance方法的執行緒t1，在判斷完singleton是null的時候，執行緒A就進入了if塊準備創造實體，但是同時另外一個執行緒B在執行緒A還未創造出實體之前，就又進行了singleton是否為null的判斷，這時singleton依然為null，所以執行緒B也會進入if塊去創造實體，這時問題就出來了，有兩個執行緒都進入了if塊去創造實體，結果就造成單例模式并非單例，
注:這里通過休眠一毫秒來模擬執行緒掛起,為初始化完instance
為了解決這個問題,我們可以采取加鎖措施,所以有了下面這種寫法
4. 懶漢式執行緒安全(粗粒度Synchronized)，
public class SingleTon{
private static SingleTon instance ;
private SingleTon(){}
public static SingleTon synchronized getInstance(){
if(instance == null){
instance = new SingleTon();
}
return instance;
}
public static void main(String[] args) {
SingleTon instance1 = SingleTon.getInstance();
SingleTon instance2 = SingleTon.getInstance();
System.out.println(instance1 == instance2);
// 通過開啟100個執行緒 比較是否是相同物件
for(int i=0;i<100;i++){
new Thread(()->
System.out.println(SingleTon.getInstance().hashCode())
).start();
}
}
}
由于第三種方式出現了執行緒不安全的問題,所以對getInstance方法加了synchronized來保證多執行緒環境下的執行緒安全性問題，這種做法雖解決了多執行緒問題但是效率比較低，
因為鎖住了整個方法，其他進入的現成都只能阻塞等待了，這樣會造成很多無謂的等待，
于是可能有人會想到可不可以讓鎖的粒度更細一點,只鎖住相關代碼塊可否？所以有了第五種寫法，關注公眾號Java技術堆疊回復多執行緒獲取我整理的系列Java多執行緒教程，
5. 懶漢式執行緒不安全(synchronized代碼塊)
public class SingleTon{
private static SingleTon instance ;
private SingleTon(){}
public static SingleTon getInstance(){
if(insatnce == null){
synchronied(SingleTon.class){
instance = new SingleTon();
}
}
return instance;
}
public static void main(String[] args) {
SingleTon instance1 = SingleTon.getInstance();
SingleTon instance2 = SingleTon.getInstance();
System.out.println(instance1 == instance2);
// 通過開啟100個執行緒 比較是否是相同物件
for(int i=0;i<100;i++){
new Thread(()->
System.out.println(SingleTon.getInstance().hashCode())
).start();
}
}
}
當并發訪問的時候，第一個呼叫getInstance方法的執行緒t1，在判斷完instance是null的時候，執行緒A就進入了if塊并且持有了synchronized鎖，但是同時另外一個執行緒t2在執行緒t1還未創造出實體之前，就又進行了instance是否為null的判斷，這時instance依然為null，所以執行緒t2也會進入if塊去創造實體，他會在synchronized代碼外面阻塞等待，直到t1釋放鎖，這時問題就出來了，有兩個執行緒都實體化了新的物件，
造成這個問題的原因就是執行緒進入了if塊并且在等待synchronized鎖的程序中有可能上一個執行緒已經創建了實體,所以進入synchronized代碼塊之后還需要在判斷一次,于是有了下面這種雙重檢驗鎖的寫法，
6. 懶漢式執行緒安全(雙重檢驗加鎖)
public class SingleTon{
private static volatile SingleTon instance ;
private SingleTon(){}
public static SingleTon getInstance(){
if(instance == null){
synchronied(SingleTon.class){
if(instance == null){
instance = new SingleTon();
}
}
}
return instance;
}
public static void main(String[] args) {
SingleTon instance1 = SingleTon.getInstance();
SingleTon instance2 = SingleTon.getInstance();
System.out.println(instance1 == instance2);
// 通過開啟100個執行緒 比較是否是相同物件
for(int i=0;i<100;i++){
new Thread(()->
System.out.println(SingleTon.getInstance().hashCode())
).start();
}
}
}
這種寫法基本趨于完美了，但是可能需要對一下幾點需要進行解釋：
-
第一個判空(外層)的作用 ？
-
第二個判空(內層)的作用 ？
-
為什么變數修飾為volatile ？
第一個判空(外層)的作用
首先，思考一下可不可以去掉最外層的判斷？答案是：可以
其實仔細觀察之后會發現最外層的判斷跟能否執行緒安全正確生成單例無關！！！
它的作用是避免每次進來都要加鎖或者等待鎖，有了同步代碼塊之外的判斷之后省了很多事，當我們的單例類實體化一個單例之后其他后續的所有請求都沒必要在進入同步代碼塊繼續往下執行了，直接回傳我們曾生成的實體即可，也就是實體還未創建時才進行同步，否則就直接回傳，這樣就節省了很多無謂的執行緒等待時間，所以最外的判斷可以認為是對提升性能有幫助，
第二個判空(內層)的作用
假設我們去掉同步塊中的是否為null的判斷，有這樣一種情況，A執行緒和B執行緒都在同步塊外面判斷了instance為null，結果t1執行緒首先獲得了執行緒鎖，進入了同步塊，然后t1執行緒會創造一個實體，此時instance已經被賦予了實體，t1執行緒退出同步塊，直接回傳了第一個創造的實體，此時t2執行緒獲得執行緒鎖，也進入同步塊，此時t1執行緒其實已經創造好了實體，t2執行緒正常情況應該直接回傳的，但是因為同步塊里沒有判斷是否為null，直接就是一條創建實體的陳述句，所以t2執行緒也會創造一個實體回傳，此時就造成創造了多個實體的情況，
為什么變數修飾為volatile
因為虛擬機在執行創建實體的這一步操作的時候，其實是分了好幾步去進行的，也就是說創建一個新的物件并非是原子性操作，在有些JVM中上述做法是沒有問題的，但是有些情況下是會造成莫名的錯誤，關注公眾號Java技術堆疊回復JVM獲取我整理的系列JVM教程，
首先要明白在JVM創建新的物件時，主要要經過三步，
1.分配記憶體
2.初始化構造器
3.將物件指向分配的記憶體的地址
因為僅僅一個new 新實體的操作就涉及三個子操作,所以生成物件的操作不是原子操作，
而實際情況是，JVM會對以上三個指令進行調優，其中有一項就是調整指令的執行順序(該操作由JIT編譯器來完成)，46張PPT弄懂JVM性能調優，這篇推薦看下，
所以，在指令被排序的情況下可能會出現問題，假如 2和3的步驟是相反的，先將分配好的記憶體地址指給instance，然后再進行初始化構造器，這時候后面的執行緒去請求getInstance方法時，會認為instance物件已經實體化了，直接回傳一個參考，
如果這時還沒進行構造器初始化并且這個執行緒使用了instance的話，則會出現執行緒會指向一個未初始化構造器的物件現象，從而發生錯誤，
7. 靜態內部類的方式(基本完美了)
public class SingleTon{
public static SingleTon getInstance(){
return StaticSingleTon.instance;
}
private static class StaticSingleTon{
private static final SingleTon instance = new SingleTon();
}
public static void main(String[] args) {
SingleTon instance1 = SingleTon.getInstance();
SingleTon instance2 = SingleTon.getInstance();
System.out.println(instance1 == instance2);
// 通過開啟100個執行緒 比較是否是相同物件
for(int i=0;i<100;i++){
new Thread(()->
System.out.println(SingleTon.getInstance().hashCode())
).start();
}
}
}
-
因為一個類的靜態屬性只會在第一次加載類時初始化，這是JVM幫我們保證的，所以我們無需擔心并發訪問的問題，所以在初始化進行一半的時候，別的執行緒是無法使用的，因為JVM會幫我們強行同步這個程序，
-
另外由于靜態變數只初始化一次，所以singleton仍然是單例的，
8. 列舉型別的單例模式(太完美以至于，，，)
public Enum SingleTon{
INSTANCE;
public static void main(String[] args) {
// 通過開啟100個執行緒 比較是否是相同物件
for(int i=0;i<100;i++){
new Thread(()->
System.out.println(SingleTon.getInstance().hashCode())
).start();
}
}
}
這種寫法從語法上看來是完美的,他解決了上面7種寫法都有的問題,就是我們可以通過反射可以生成新的實體，但是列舉的這種寫法是無法通過反射來生成新的實體,因為列舉沒有public構造方法，
關注公眾號Java技術堆疊回復"面試"獲取我整理的2020最全面試題及答案，
推薦去我的博客閱讀更多：
1.Java JVM、集合、多執行緒、新特性系列教程
2.Spring MVC、Spring Boot、Spring Cloud 系列教程
3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程
4.Java、后端、架構、阿里巴巴等大廠最新面試題
覺得不錯，別忘了點贊+轉發哦！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/136601.html
標籤：Java