看公司代碼的時候發(fā)現(xiàn)項目中單例模式應(yīng)用挺多的，并且發(fā)現(xiàn)的兩處單例模式用的還是不同的方式實現(xiàn)的，那么單例模式到底有幾種寫法呢？單例模式看似很簡單，但是實際寫起來卻問題多多
本文大綱
- 什么是單例模式
- 餓漢式創(chuàng)建單例對象
- 懶漢式創(chuàng)建單例對象
- 單例模式的優(yōu)缺點
- 單例模式的應(yīng)用場景
什么是單例模式
確保某個類只有一個實例，而且自行實例化并向整個系統(tǒng)提供這個實例，并且有兩種創(chuàng)建方式，一種是餓漢式創(chuàng)建，另外一種是懶漢式創(chuàng)建
餓漢式創(chuàng)建單例模式
餓漢式創(chuàng)建就是在類加載時就已創(chuàng)建好對象，而不是在需要時在創(chuàng)建對象
public class HungrySingleton {
private static HungrySingleton hungrySingleton = new HungrySingleton();
/**
* 私有構(gòu)造函數(shù)，不能被外部所訪問
*/
private HungrySingleton() {}
/**
* 返回單例對象
* */
public static HungrySingleton getHungrySingleton() {
return hungrySingleton;
}
}
說明：
- 構(gòu)造函數(shù)私有化，保證外部不能調(diào)用構(gòu)造函數(shù)創(chuàng)建對象，創(chuàng)建對象的行為只能由這個類決定
- 只能通過
getHungrySingleton方法獲取對象 -
HungrySingleton對象已經(jīng)創(chuàng)建完成【在類加載時創(chuàng)建】
缺點：
- 如果
getHungrySingleton一直沒有被使用到，有點浪費資源
優(yōu)點：
- 由
ClassLoad保證線程安全
懶漢式創(chuàng)建單例模式
懶漢式創(chuàng)建就是在第一次需要該對象時在創(chuàng)建
-
存在錯誤的懶漢式創(chuàng)建單例對象
根據(jù)定義很容易在上面餓漢式的基礎(chǔ)上進行修改public class LazySingleton { private static LazySingleton lazySingleton = null; /** * 構(gòu)造函數(shù)私有化 * */ private LazySingleton() { } private static LazySingleton getLazySingleton() { if (lazySingleton == null) { return new LazySingleton(); } return lazySingleton; } }說明：
- 構(gòu)造函數(shù)私有化
- 當需要時【
getLazySingleton方法調(diào)用時】才創(chuàng)建
嗯，好像沒什么問題，但是當有多個線程同時調(diào)用getLazySingleton方法時，此時剛好對象沒有初始化，兩個線程同時通過lazySingleton == null的校驗，將會創(chuàng)建兩個LazySingleton對象。必須搞點手段使getLazySingleton方法是線程安全的
-
synchronize或Lock
很容易想到使用synchronize或Lock對方法進行加鎖
使用synchronize：public class LazySynchronizeSingleton { private static LazySynchronizeSingleton lazySynchronizeSingleton= null; /** * 構(gòu)造函數(shù)私有化 * */ private LazySynchronizeSingleton() { } public synchronized static LazySynchronizeSingleton getLazySynchronizeSingleton() { if (lazySynchronizeSingleton == null) { lazySynchronizeSingleton = new LazySynchronizeSingleton(); } return lazySynchronizeSingleton; } }使用
Lock：public class LazyLockSingleton { private static LazyLockSingleton lazyLockSingleton = null; /** * 鎖 **/ private static Lock lock = new ReentrantLock(); /** * 構(gòu)造函數(shù)私有化 * */ private LazyLockSingleton() { } public static LazyLockSingleton getLazyLockSingleton() { try { lock.lock(); if (lazyLockSingleton == null) { lazyLockSingleton = new LazyLockSingleton(); } } finally { lock.unlock(); } return lazyLockSingleton; } }這兩種方式雖然保證了線程安全，但是性能較差，因為線程不安全主要是由這段代碼引起的：
if (lazyLockSingleton == null) { lazyLockSingleton = new LazyLockSingleton(); }給方法加鎖無論對象是否已經(jīng)初始化都會造成線程阻塞。如果對象為
null的情況下才進行加鎖，對象不為null的時候則不進行加鎖，那么性能將會得到提升，雙重鎖檢查可以實現(xiàn)這個需求 雙重鎖檢查
在加鎖之前先判斷lazyDoubleCheckSingleton == null是否成立，如果不成立直接返回創(chuàng)建好的對象，成立在加鎖
public class LazyDoubleCheckSingleton {
/**
* 使用volatile進行修飾，禁止指令重排
* */
private static volatile LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;
/**
* 構(gòu)造函數(shù)私有化
* */
private LazyDoubleCheckSingleton() {
}
public static LazyDoubleCheckSingleton getLazyDoubleCheckSingleton() {
if (lazyDoubleCheckSingleton == null) {
synchronized (LazyDoubleCheckSingleton.class) {
if (lazyDoubleCheckSingleton == null) {
lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();
}
}
}
return lazyDoubleCheckSingleton;
}
}
說明：
- 為什么需要對
lazyDoubleCheckSingleton添加volatile修飾符
因為lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();不是原子性的，分為三步：- 為
lazyDoubleCheckSingleton分配內(nèi)存 - 調(diào)用構(gòu)造函數(shù)進行初始化
- 將
lazyDoubleCheckSingleton對象指向分配的內(nèi)存【執(zhí)行完這步lazyDoubleCheckSingleton將不為null】為了提高程序的運行效率，編譯器會進行一個指令重排，步驟2和步驟三進行了重排，線程1先執(zhí)行了步驟一和步驟三，執(zhí)行完后，lazyDoubleCheckSingleton不為null，此時線程2執(zhí)行到if (lazyDoubleCheckSingleton == null)，線程2將可能直接返回未正確進行初始化的lazyDoubleCheckSingleton對象。出錯的原因主要是lazyDoubleCheckSingleton未正確初始化完成【寫】，但是其他線程已經(jīng)讀取lazyDoubleCheckSingleton的值【讀】，使用volatile可以禁止指令重排序，通過內(nèi)存屏障保證寫操作之前不會調(diào)用讀操作【執(zhí)行if (lazyDoubleCheckSingleton == null)】
- 為
缺點：
為了保證線程安全，代碼不夠優(yōu)雅過于臃腫
-
靜態(tài)內(nèi)部類
public class LazyStaticSingleton { /** * 靜態(tài)內(nèi)部類 * */ private static class LazyStaticSingletonHolder { private static LazyStaticSingleton lazyStaticSingleton = new LazyStaticSingleton(); } /** * 構(gòu)造函數(shù)私有化 * */ private LazyStaticSingleton() { } public static LazyStaticSingleton getLazyStaticSingleton() { return LazyStaticSingletonHolder.lazyStaticSingleton; } }靜態(tài)內(nèi)部類在調(diào)用時才會進行初始化，因此是懶漢式的，
LazyStaticSingleton lazyStaticSingleton = new LazyStaticSingleton();看似是餓漢式的，但是只有調(diào)用getLazyStaticSingleton時才會進行初始化，線程安全由ClassLoad保證，不用思考怎么加鎖
前面幾種方式實現(xiàn)單例的方式雖然各有優(yōu)缺點，但是基本實現(xiàn)了單例線程安全的要求。但是總有人看不慣單例模式勤儉節(jié)約的優(yōu)點，對它進行攻擊。對它進行攻擊無非就是創(chuàng)建不只一個類，java中創(chuàng)建對象的方式有new、clone、序列化、反射。構(gòu)造函數(shù)私有化不可能通過new創(chuàng)建對象、同時單例類沒有實現(xiàn)Cloneable接口無法通過clone方法創(chuàng)建對象，那剩下的攻擊只有反射攻擊和序列化攻擊了
反射攻擊：
public class ReflectAttackTest {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//靜態(tài)內(nèi)部類
LazyStaticSingleton lazyStaticSingleton = LazyStaticSingleton.getLazyStaticSingleton();
//通過反射創(chuàng)建LazyStaticSingleton
Constructor<LazyStaticSingleton> constructor = LazyStaticSingleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
LazyStaticSingleton lazyStaticSingleton1 = constructor.newInstance();
//打印結(jié)果為false，說明又創(chuàng)建了一個新對象
System.out.println(lazyStaticSingleton == lazyStaticSingleton1);
//synchronize
LazySynchronizeSingleton lazySynchronizeSingleton = LazySynchronizeSingleton.getLazySynchronizeSingleton();
Constructor<LazySynchronizeSingleton> lazySynchronizeSingletonConstructor = LazySynchronizeSingleton.class.getDeclaredConstructor();
lazySynchronizeSingletonConstructor.setAccessible(true);
LazySynchronizeSingleton lazySynchronizeSingleton1 = lazySynchronizeSingletonConstructor.newInstance();
System.out.println(lazySynchronizeSingleton == lazySynchronizeSingleton1);
//lock
LazyLockSingleton lazyLockSingleton = LazyLockSingleton.getLazyLockSingleton();
Constructor<LazyLockSingleton> lazyLockSingletonConstructor = LazyLockSingleton.class.getDeclaredConstructor();
lazyLockSingletonConstructor.setAccessible(true);
LazyLockSingleton lazyLockSingleton1 = lazyLockSingletonConstructor.newInstance();
System.out.println(lazyLockSingleton == lazyLockSingleton1);
//雙重鎖檢查
LazyDoubleCheckSingleton lazyDoubleCheckSingleton = LazyDoubleCheckSingleton.getLazyDoubleCheckSingleton();
Constructor<LazyDoubleCheckSingleton> lazyDoubleCheckSingletonConstructor = LazyDoubleCheckSingleton.class.getDeclaredConstructor();
lazyDoubleCheckSingletonConstructor.setAccessible(true);
LazyDoubleCheckSingleton lazyDoubleCheckSingleton1 = lazyDoubleCheckSingletonConstructor.newInstance();
System.out.println(lazyDoubleCheckSingleton == lazyDoubleCheckSingleton1);
}
}
都存在反射攻擊，都可以創(chuàng)建出一個新對象，打印結(jié)果都為false。針對存在的反射攻擊根據(jù)網(wǎng)上提供的思路在搶救一下，搶救姿勢如下：
private LazySynchronizeSingleton() {
//flag為線程間共享，進行加鎖控制
synchronized (LazySynchronizeSingleton.class) {
if (flag == false) {
flag = !flag;
} else {
throw new RuntimeException("單例模式被攻擊");
}
}
}
構(gòu)造函數(shù)只能調(diào)用一次，調(diào)用第二次將拋出異常，通過flag來判斷構(gòu)造函數(shù)是否已經(jīng)被調(diào)用過一次了。但是我們?nèi)钥梢酝ㄟ^反射修改flag的值：
//調(diào)用反射前將flag設(shè)置為false
Field flagField = lazySynchronizeSingleton.getClass().getDeclaredField("flag");
flagField.setAccessible(true);
flagField.set(lazySynchronizeSingleton, false);
搶救失敗，你可能想通過final修飾禁止修改，但是反射可以先去除final，在加上final修改值，對于反射攻擊，無力回天，只能選擇不適用存在反射攻擊的單例創(chuàng)建方式
反序列化攻擊：
public class SerializableAttackTest {
public static void main(String[] args) {
//懶漢式
HungrySingleton hungrySingleton = HungrySingleton.getHungrySingleton();
//序列化
byte[] serialize = SerializationUtils.serialize(hungrySingleton);
//反序列化
HungrySingleton hungrySingleton1 = SerializationUtils.deserialize(serialize);
System.out.println(hungrySingleton == hungrySingleton1);
//雙重鎖
LazyDoubleCheckSingleton lazyDoubleCheckSingleton = LazyDoubleCheckSingleton.getLazyDoubleCheckSingleton();
byte[] serialize1 = SerializationUtils.serialize(lazyDoubleCheckSingleton);
LazyDoubleCheckSingleton lazyDoubleCheckSingleton11 = SerializationUtils.deserialize(serialize1);
System.out.println(lazyDoubleCheckSingleton == lazyDoubleCheckSingleton11);
//lock
LazyLockSingleton lazyLockSingleton = LazyLockSingleton.getLazyLockSingleton();
byte[] serialize2 = SerializationUtils.serialize(lazyLockSingleton);
LazyLockSingleton lazyLockSingleton1 = SerializationUtils.deserialize(serialize2);
System.out.println(lazyLockSingleton == lazyLockSingleton1);
//synchronie
LazySynchronizeSingleton lazySynchronizeSingleton = LazySynchronizeSingleton.getLazySynchronizeSingleton();
byte[] serialize3 = SerializationUtils.serialize(lazySynchronizeSingleton);
LazySynchronizeSingleton lazySynchronizeSingleton1 = SerializationUtils.deserialize(serialize3);
System.out.println(lazySynchronizeSingleton == lazySynchronizeSingleton1);
//靜態(tài)內(nèi)部類
LazyStaticSingleton lazyStaticSingleton = LazyStaticSingleton.getLazyStaticSingleton();
byte[] serialize4 = SerializationUtils.serialize(lazySynchronizeSingleton);
LazyStaticSingleton lazyStaticSingleton1 = SerializationUtils.deserialize(serialize4);
System.out.println(lazyStaticSingleton == lazyStaticSingleton1);
}
}
打印結(jié)果都為false，都存在反序列化攻擊
對于反序列化攻擊，還是有有效的搶救方式的，搶救姿勢如下：
private Object readResolve() {
return lazySynchronizeSingleton;
}
復(fù)制代碼
添加readResolve方法并返回創(chuàng)建的單例對象，至于搶救的原理，可以通過跟進SerializationUtils.deserialize的代碼可知
上述實現(xiàn)單例對象的方式既要考慮線程安全、又要考慮攻擊，而通過枚舉創(chuàng)建單例對象完全不用擔(dān)心這些問題
-
枚舉
public enum EnumSingleton { INSTANCE; public static EnumSingleton getEnumSingleton() { return INSTANCE; } }代碼實現(xiàn)也相當優(yōu)美，總共才
8行代
實現(xiàn)原理：枚舉類的域(field)其實是相應(yīng)的enum類型的一個實例對象
可以參考：implementing-singleton-with-an-enum-in-java
枚舉攻擊測試：public class EnumAttackTest { public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException { EnumSingleton enumSingleton = EnumSingleton.getEnumSingleton(); //序列化攻擊 byte[] serialize4 = SerializationUtils.serialize(enumSingleton); EnumSingleton enumSingleton2 = SerializationUtils.deserialize(serialize4); System.out.println(enumSingleton == enumSingleton2); //反射攻擊 Constructor<EnumSingleton> enumSingletonConstructor = EnumSingleton.class.getDeclaredConstructor(); enumSingletonConstructor.setAccessible(true); EnumSingleton enumSingleton1 = enumSingletonConstructor.newInstance(); System.out.println(enumSingleton == enumSingleton1); } }反射攻擊將會拋出異常，序列化攻擊對它無效，打印結(jié)果為
true，用枚舉創(chuàng)建單例對象真的是無懈可擊
單例模式的優(yōu)點
- 只創(chuàng)建了一個實例，節(jié)省內(nèi)存開銷
- 減少了系統(tǒng)的性能開銷，創(chuàng)建對象回收對象對性能都有一定的影響
- 避免對資源的多重占用
- 在系統(tǒng)設(shè)置全局的訪問點，優(yōu)化和共享資源優(yōu)化
總結(jié)一下就是節(jié)約資源、提升性能
單例模式的缺點
- 不適用于變化的對象
- 單例模式中沒有抽象層，擴展有困難
- 與單一原則沖突。一個類應(yīng)該只實現(xiàn)一個邏輯，而不關(guān)心它是否單例，是不是單例應(yīng)該由業(yè)務(wù)決定
單例模式的應(yīng)用場景
-
Spring IOC默認使用單例模式創(chuàng)建bean - 創(chuàng)建對象需要消耗的資源過多時
- 需要定義大量的靜態(tài)常量和靜態(tài)方法的環(huán)境，比如工具類【感覺是最常見應(yīng)用場景】
小結(jié)
總共介紹了六種正確創(chuàng)建單例對象的方式，推薦使用餓漢式創(chuàng)建單例對象的方式，如果對資源使用有要求，則推薦使用靜態(tài)內(nèi)部類【注意反序列化攻擊】，其他方式在保證線程安全的同時對性能將會有影響。枚舉類其實是非常不錯的，線程安全、不存在反射攻擊和反序列化攻擊，但是感覺這種創(chuàng)建單例方式應(yīng)用較少，公司代碼中使用的是雙重鎖檢查和靜態(tài)內(nèi)部類【存在反序列化攻擊】創(chuàng)建單例方式，甚至之前出去面試時面試官讓寫一個單例，我使用的是枚舉方式，面試官都不知道有這種方式
