[[358261]]

 本文轉(zhuǎn)載自微信公眾號(hào)「丙丙」，作者丙丙 。轉(zhuǎn)載本文請(qǐng)聯(lián)系丙丙公眾號(hào)。

從去年開始，Java程序員們換工作面試越來越難，不懂多線程，JVM，mysql，以及一些分布式的組件都不好意思出去面試。

也經(jīng)常聽到身邊的同學(xué)說身邊誰面試題目很簡單，自己也會(huì)，但是真到自己的時(shí)候你能就一個(gè)知識(shí)點(diǎn)講的很透徹，并且能夠發(fā)散思考引出更多的答案嗎?

這道手寫一個(gè)單例模式的筆試題，應(yīng)該很多程序員老鐵都碰到過，剛看到題目的時(shí)候可能很驚喜，覺得自己運(yùn)氣真好，但是你真的能夠100%做好這道題嗎?

請(qǐng)手寫一個(gè)單例，要求線程安全。

首先給單例下一個(gè)定義：在當(dāng)前進(jìn)程中，通過單例模式創(chuàng)建的類有且只有一個(gè)實(shí)例。

單例有如下幾個(gè)特點(diǎn)：

• 在Java應(yīng)用中，單例模式能保證在一個(gè)JVM中，該對(duì)象只有一個(gè)實(shí)例存在
• 構(gòu)造器必須是私有的，外部類無法通過調(diào)用構(gòu)造器方法創(chuàng)建該實(shí)例
• 沒有公開的set方法，外部類無法調(diào)用set方法創(chuàng)建該實(shí)例
• 提供一個(gè)公開的get方法獲取唯一的這個(gè)實(shí)例

那單例模式有什么好處呢?

某些類創(chuàng)建比較頻繁，對(duì)于一些大型的對(duì)象，這是一筆很大的系統(tǒng)開銷

省去了new操作符，降低了系統(tǒng)內(nèi)存的使用頻率，減輕GC壓力

系統(tǒng)中某些類，如spring里的controller，控制著處理流程，如果該類可以創(chuàng)建多個(gè)的話，系統(tǒng)完全亂了

好了，單例模式的定義也清楚了，好處也了解了，先看一個(gè)餓漢式的寫法

public class Singleton { 
    private static Singleton instance = new Singleton(); 
    /** 
     * 私有構(gòu)造方法，防止被實(shí)例化 
     */ 
    private Singleton(){} 
    /** 
     * 靜態(tài)get方法 
     */ 
    public static Singleton getInstance(){ 
        return instance; 
    } 
} 

如果面試時(shí)提供的是這個(gè)答案，那丙丙建議你先回家埋頭苦讀兩個(gè)月再出來找工作了，你肯定說這個(gè)也太low了，一看就是線程不安全的，方法應(yīng)該通過synchronized給鎖起來，同時(shí)創(chuàng)建前先校驗(yàn)一下，改造后寫法如下：

public class Singleton { 
    private static Singleton instance = null; 
    /** 
     * 私有構(gòu)造方法，防止被實(shí)例化 
     */ 
    private Singleton(){} 
    /** 
     * 靜態(tài)get方法 
     */ 
    public static synchronized Singleton getInstance(){ 
        if(instance == null){ 
            instance = new Singleton(); 
        } 
        return instance; 
    } 
} 

這是一種典型的時(shí)間換空間的寫法，不管三七二十一，每次創(chuàng)建實(shí)例時(shí)先鎖起來，再進(jìn)行判斷，嚴(yán)重降低了系統(tǒng)的處理速度。

有沒有更好的處理方式呢?

有，通過雙檢鎖做兩次判斷，代碼如下：

public class Singleton { 
    private static Singleton instance = null; 
    private Singleton(){} 
    public static Singleton getInstance(){ 
        //先檢查實(shí)例是否存在，如果不存在才進(jìn)入下面的同步塊 
        if(instance == null){ 
            //同步塊，線程安全的創(chuàng)建實(shí)例 
            synchronized (Singleton.class) { 
                //再次檢查實(shí)例是否存在，如果不存在才真正的創(chuàng)建實(shí)例 
                if(instance == null){ 
                    instance = new Singleton(); 
                } 
            } 
        } 
        return instance; 
    } 
} 

將synchronized關(guān)鍵字加在了內(nèi)部，也就是說當(dāng)調(diào)用的時(shí)候是不需要加鎖的，只有在instance為null，并創(chuàng)建對(duì)象的時(shí)候才需要加鎖，性能有一定的提升。

但是，這樣就沒有問題了嗎?

看下面的情況：在Java指令中創(chuàng)建對(duì)象和賦值操作是分開進(jìn)行的，也就是說instance = new Singleton();語句是分兩步執(zhí)行的。

但是JVM并不保證這兩個(gè)操作的先后順序，也就是說有可能JVM會(huì)為新的Singleton實(shí)例分配空間，然后直接賦值給instance成員，然后再去初始化這個(gè)Singleton實(shí)例。

這樣就可能出錯(cuò)了，我們以A、B兩個(gè)線程為例：

• A、B線程同時(shí)進(jìn)入了第一個(gè)if判斷
• A首先進(jìn)入synchronized塊，由于instance為null，所以它執(zhí)行instance = new Singleton();
• 由于JVM內(nèi)部的優(yōu)化機(jī)制，JVM先畫出了一些分配給Singleton實(shí)例的空白內(nèi)存，并賦值給instance成員(注意此時(shí)JVM沒有開始初始化這個(gè)實(shí)例)，然后A離開了synchronized塊。

image-20201212010622553

• B進(jìn)入synchronized塊，由于instance此時(shí)不是null，因此它馬上離開了synchronized塊并將結(jié)果返回給調(diào)用該方法的程序。
• 此時(shí)B線程打算使用Singleton實(shí)例，卻發(fā)現(xiàn)它沒有被初始化，于是錯(cuò)誤發(fā)生了。

加上volatile修飾Singleton，再做一次優(yōu)化：

public class Singleton { 
    private volatile static Singleton instance = null; 
    private Singleton(){} 
    public static Singleton getInstance(){ 
        //先檢查實(shí)例是否存在，如果不存在才進(jìn)入下面的同步塊 
        if(instance == null){ 
            //同步塊，線程安全的創(chuàng)建實(shí)例 
            synchronized (Singleton.class) { 
                //再次檢查實(shí)例是否存在，如果不存在才真正的創(chuàng)建實(shí)例 
                if(instance == null){ 
                    instance = new Singleton(); 
                } 
            } 
        } 
        return instance; 
    } 
} 

**通過volatile修飾的變量，不會(huì)被線程本地緩存，所有線程對(duì)該對(duì)象的讀寫都會(huì)第一時(shí)間同步到主內(nèi)存，從而保證多個(gè)線程間該對(duì)象的準(zhǔn)確性 **

volatile的作用

防止指令重排序，因?yàn)閕nstance = new Singleton()不是原子操作

保證內(nèi)存可見

這個(gè)是比較完美的寫法了，這種方式能夠安全的創(chuàng)建唯一的一個(gè)實(shí)例，又不會(huì)對(duì)性能有太大的影響。

但是由于volatile關(guān)鍵字可能會(huì)屏蔽掉虛擬機(jī)中一些必要的代碼優(yōu)化，所以運(yùn)行效率并不是很高，還有更優(yōu)的寫法嗎?

通過靜態(tài)內(nèi)部類

public class Singleton {   
   
    /* 私有構(gòu)造方法，防止被實(shí)例化 */   
    private Singleton() {   
    }   
   
    /* 此處使用一個(gè)內(nèi)部類來維護(hù)單例 */   
    private static class SingletonFactory {   
        private static Singleton instance = new Singleton();   
    }   
   
    /* 獲取實(shí)例 */   
    public static Singleton getInstance() {   
        return SingletonFactory.instance;   
    }   
   
    /* 如果該對(duì)象被用于序列化，可以保證對(duì)象在序列化前后保持一致 */   
    public Object readResolve() {   
        return getInstance();   
    }   
}   

使用內(nèi)部類來維護(hù)單例的實(shí)現(xiàn)，JVM內(nèi)部的機(jī)制能夠保證當(dāng)一個(gè)類被加載的時(shí)候，這個(gè)類的加載過程是線程互斥的。

這樣當(dāng)我們第一次調(diào)用getInstance的時(shí)候，JVM能夠幫我們保證instance只被創(chuàng)建一次，并且會(huì)保證把賦值給instance的內(nèi)存初始化完畢， 這樣我們就不用擔(dān)心上面的問題。

同時(shí)該方法也只會(huì)在第一次調(diào)用的時(shí)候使用互斥機(jī)制，這樣就解決了低性能問題。這樣我們暫時(shí)總結(jié)一個(gè)完美的單例模式。

還有更完美的寫法嗎,通過枚舉：

public enum Singleton { 
    /** 
     * 定義一個(gè)枚舉的元素，它就代表了Singleton的一個(gè)實(shí)例。 
     */ 
    Instance; 
} 

使用枚舉來實(shí)現(xiàn)單實(shí)例控制會(huì)更加簡潔，而且JVM從根本上提供保障，絕對(duì)防止多次實(shí)例化，是更簡潔、高效、安全的實(shí)現(xiàn)單例的方式。