設計模式 - 單例模式(詳解)看看和你理解的是否一樣?
一、概述
單例模式是設計模式中相對簡單且非常常見的一種設計模式,但是同時也是非常經典的高頻面試題,相信還是有很多人在面試時會掛在這裡。本篇文章主要針對單例模式做一個回顧,記錄單例模式的應用場景、常見寫法、針對執行緒安全進行除錯(看得見的執行緒)以及總結。相信大家看完這篇文章之後,對單例模式有一個非常深刻的認識。
文章中按照常見的單例模式的寫法,由淺入深進行講解記錄;以及指出該寫法的不足,從而進行演進改造。
秉承廢話少說的原則,我們下面快速開始
二、定義
單例模式(Singleton Pattern)是指確保一個類在任何情況下都絕對只有一個例項,並提供一個全域性訪問點。
單例模式是建立型模式。
三、應用場景
- 生活中的單例:例如,國家主席、公司 CEO、部門經理等。
- 在
Java
世界中:ServletContext
、ServletContextConfig
等; - 在
Spring
框架應用中:ApplicationContext
、資料庫的連線池也都是單例形式。
四、常見的單例模式寫法
單例模式主要有:餓漢式單例、懶漢式單例(執行緒不安全型、執行緒安全型、雙重檢查鎖型別、靜態內部型別別)、註冊式(登記式)單例(列舉式單例、容器式單例)、
ThreadLocal
執行緒單例
下面我們來看看各種模式的寫法。
1、餓漢式單例
餓漢式單例是在類載入的時候就立即初始化,並且建立單例物件。絕對執行緒安全,線上程還沒出現以前就是例項化了,不可能存在訪問安全問題。
Spring 中 IOC 容器 ApplicationContext 就是典型的餓漢式單例
優缺點
優點:沒有加任何的鎖、執行效率比較高,在使用者體驗上來說,比懶漢式更好。
缺點:類載入的時候就初始化,不管用與不用都佔著空間,浪費了記憶體,有可能佔著茅坑不拉屎。
寫法
/**
* @author eamon.zhang
* @date 2019-09-30 上午9:26
*/
public class HungrySingleton {
// 1.私有化構造器
private HungrySingleton (){}
// 2.在類的內部建立自行例項
private static final HungrySingleton instance = new HungrySingleton();
// 3.提供獲取唯一例項的方法(全域性訪問點)
public static HungrySingleton getInstance(){
return instance;
}
}
複製程式碼
還有另外一種寫法,利用靜態程式碼塊的機制:
/**
* @author eamon.zhang
* @date 2019-09-30 上午10:46
*/
public class HungryStaticSingleton {
// 1. 私有化構造器
private HungryStaticSingleton(){}
// 2. 例項變數
private static final HungryStaticSingleton instance;
// 3. 在靜態程式碼塊中例項化
static {
instance = new HungryStaticSingleton();
}
// 4. 提供獲取例項方法
public static HungryStaticSingleton getInstance(){
return instance;
}
}
複製程式碼
測試程式碼,我們建立 10 個執行緒(具體執行緒發令槍 ConcurrentExecutor 在文末原始碼中獲取):
/**
* @author eamon.zhang
* @date 2019-09-30 上午11:17
*/
public class HungrySingletonTest {
@Test
public void test() {
try {
ConcurrentExecutor.execute(() -> {
HungrySingleton instance = HungrySingleton.getInstance();
System.out.println(Thread.currentThread().getName() + " : " + instance);
},10,10);
} catch (Exception e) {
e.printStackTrace();
}
}
}
複製程式碼
測試結果:
pool-1-thread-6 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
pool-1-thread-1 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
pool-1-thread-9 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
pool-1-thread-10 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
pool-1-thread-2 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
pool-1-thread-7 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
pool-1-thread-5 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
pool-1-thread-3 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
pool-1-thread-4 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
pool-1-thread-8 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
...
複製程式碼
可以看到,餓漢式每次獲取例項都是同一個。
使用場景
這兩種寫法都非常的簡單,也非常好理解,餓漢式適用在單例物件較少的情況。
下面我們來看效能更優的寫法——懶漢式單例。
2、懶漢式單例
懶漢式單例的特點是:被外部類呼叫的時候內部類才會載入。
懶漢式單例可以分為下面這幾種寫法來。
簡單懶漢式(執行緒不安全)
這是懶漢式單例的簡單寫法
/**
* @author eamon.zhang
* @date 2019-09-30 上午10:55
*/
public class LazySimpleSingleton {
private LazySimpleSingleton(){}
private static LazySimpleSingleton instance = null;
public static LazySimpleSingleton getInstance(){
if (instance == null) {
instance = new LazySimpleSingleton();
}
return instance;
}
}
複製程式碼
我們建立一個多執行緒來測試一下,是否執行緒安全:
/**
* @author eamon.zhang
* @date 2019-09-30 上午11:12
*/
public class LazySimpleSingletonTest {
@Test
public void test() {
try {
ConcurrentExecutor.execute(() -> {
LazySimpleSingleton instance = LazySimpleSingleton.getInstance();
System.out.println(Thread.currentThread().getName() + " : " + instance);
},5,5);
} catch (Exception e) {
e.printStackTrace();
}
}
}
複製程式碼
執行結果:
pool-1-thread-3 : com.eamon.javadesignpatterns.singleton.lazy.LazySimpleSingleton@abe194f
pool-1-thread-5 : com.eamon.javadesignpatterns.singleton.lazy.LazySimpleSingleton@abe194f
pool-1-thread-1 : com.eamon.javadesignpatterns.singleton.lazy.LazySimpleSingleton@748e48d0
pool-1-thread-2 : com.eamon.javadesignpatterns.singleton.lazy.LazySimpleSingleton@abe194f
pool-1-thread-4 : com.eamon.javadesignpatterns.singleton.lazy.LazySimpleSingleton@abe194f
複製程式碼
從測試結果來看,一定機率出現建立兩個不同結果的情況,意味著上面的單例存線上程安全隱患。
至於為什麼?由於篇幅問題,我們在後面一篇文章中利用測試工具進行詳細的分析(這可能也是面試中面試官會問到的問題)。大家現在只需要知道簡單的懶漢式會存在這麼一個問題就行了。
簡單懶漢式(執行緒安全)
通過對上面簡單懶漢式單例的測試,我們知道存線上程安全隱患,那麼,如何來避免或者解決呢?
我們都知道 java 中有一個synchronized
可以來對共享資源進行加鎖,保證在同一時刻只能有一個執行緒拿到該資源,其他執行緒只能等待。所以,我們對上面的簡單懶漢式進行改造,給getInstance()
方法加上synchronized
:
/**
* @author eamon.zhang
* @date 2019-09-30 上午10:55
*/
public class LazySimpleSyncSingleton {
private LazySimpleSyncSingleton() {
}
private static LazySimpleSyncSingleton instance = null;
public synchronized static LazySimpleSyncSingleton getInstance() {
if (instance == null) {
instance = new LazySimpleSyncSingleton();
}
return instance;
}
}
複製程式碼
然後使用發令槍進行測試:
@Test
public void testSync(){
try {
ConcurrentExecutor.execute(() -> {
LazySimpleSyncSingleton instance = LazySimpleSyncSingleton.getInstance();
System.out.println(Thread.currentThread().getName() + " : " + instance);
},5);
} catch (Exception e) {
e.printStackTrace();
}
}
複製程式碼
進行多輪測試,並觀察結果,發現能夠獲取同一個示例:
pool-1-thread-3 : com.eamon.javadesignpatterns.singleton.lazy.simple.LazySimpleSyncSingleton@1a7e99de
pool-1-thread-2 : com.eamon.javadesignpatterns.singleton.lazy.simple.LazySimpleSyncSingleton@1a7e99de
pool-1-thread-5 : com.eamon.javadesignpatterns.singleton.lazy.simple.LazySimpleSyncSingleton@1a7e99de
pool-1-thread-1 : com.eamon.javadesignpatterns.singleton.lazy.simple.LazySimpleSyncSingleton@1a7e99de
pool-1-thread-4 : com.eamon.javadesignpatterns.singleton.lazy.simple.LazySimpleSyncSingleton@1a7e99de
複製程式碼
執行緒安全問題是解決了,但是,用synchronized
加鎖,線上程數量比較多情況下,如果CPU
分配壓力上升,會導致大批量執行緒出現阻塞,從而導致程式執行效能大幅下降。
那麼,有沒有一種更好的方式,既兼顧執行緒安全又提升程式效能呢?答案是肯定的。
我們來看雙重檢查鎖的單例模式。
雙重檢查鎖懶漢式
上面的執行緒安全方式的寫法,synchronized
鎖是鎖在 getInstance()
方法上,當多個執行緒過來拿資源的時候,其實需要拿的不是getInstance()
這個方法,而是getInstance()
方法裡面的instance
例項物件,而如果這個例項物件一旦被初始化之後,多個執行緒到達時,就可以利用方法中的 if (instance == null)
去判斷是否例項化,如果已經例項化了就直接返回,就沒有必要再進行例項化一遍。所以對上面的程式碼進行改造:
第一次改造:
/**
* @author eamon.zhang
* @date 2019-09-30 下午2:03
*/
public class LazyDoubleCheckSingleton {
private LazyDoubleCheckSingleton() {
}
private static LazyDoubleCheckSingleton instance = null;
public static LazyDoubleCheckSingleton getInstance() {
// 這裡判斷是為了過濾不必要的同步加鎖,因為如果已經例項化了,就可以直接返回了
if (instance == null) {
// 如果未初始化,則對資源進行上鎖保護,待例項化完成之後進行釋放
synchronized (LazyDoubleCheckSingleton.class) {
instance = new LazyDoubleCheckSingleton();
}
}
return instance;
}
}
複製程式碼
這種方法行不行?答案肯定是不行,程式碼中雖然是將同步鎖新增到了例項化操作中,解決了每個執行緒由於同步鎖的原因引起的阻塞,提高了效能;但是,這裡會存在一個問題:
-
執行緒X
和執行緒Y
同時呼叫getInstance()
方法,他們同時判斷instance == null
,得出的結果都是為null
,所以進入了if
程式碼塊了 - 此時
執行緒X
得到CPU
的控制權 -> 進入同步程式碼塊 -> 建立物件 -> 返回物件 -
執行緒X
執行完成了以後,釋放了鎖,然後執行緒Y
得到了CPU
的控制權。同樣是 -> 進入同步程式碼塊 -> 建立物件 -> 返回物件
所以我們明顯可以分析出來:LazyDoubleCheckSingleton
類返回了不止一個例項!所以上面的程式碼是不行的!大家可以自行測試,我這裡就不進行測試了!
我們再進行改造,經過分析,由於執行緒X
已經例項化了物件,在執行緒Y
再次進入的時候,我們再加一層判斷不就可以解決 “這個” 問題嗎?確實如此,來看程式碼:
/**
* @author eamon.zhang
* @date 2019-09-30 下午2:03
*/
public class LazyDoubleCheckSingleton {
private LazyDoubleCheckSingleton() {
}
private static LazyDoubleCheckSingleton instance = null;
public static LazyDoubleCheckSingleton getInstance() {
// 這裡判斷是為了過濾不必要的同步加鎖,因為如果已經例項化了,就可以直接返回了
if (instance == null) {
// 如果未初始化,則對資源進行上鎖保護,待例項化完成之後進行釋放(注意,可能多個執行緒會同時進入)
synchronized (LazyDoubleCheckSingleton.class) {
// 這裡的if作用是:如果後面的程式在前面一個執行緒例項化完成之後拿到鎖,進入這個程式碼塊,
// 顯然,資源已經被例項化過了,所以需要進行判斷過濾
if (instance == null) {
instance = new LazyDoubleCheckSingleton();
}
}
}
return instance;
}
}
複製程式碼
大家覺得經過這樣改造是不是就完美了呢?在我們習慣性的“講道理”的思維模式看來,好像確實沒什麼問題,但是,程式是計算機在執行;什麼意思呢?
在 instance = new LazyDoubleCheckSingleton();
這段程式碼執行的時候,計算機內部並非簡單的一步操作,也就是非原子操作,在JVM
中,這一行程式碼大概做了這麼幾件事情:
- 給
instance
分配記憶體 - 呼叫
LazyDoubleCheckSingleton
的建構函式來初始化成員變數 - 將
instance
物件指向分配的記憶體空間(執行完這步instance
就為非 null 了)
但是在 JVM
中的即時編譯器中存在指令重排序的優化;通俗的來說就是,上面的第二步和第三步的順序是不能保證的,如果執行順序是 1 -> 3 -> 2
那麼在 3 執行完畢、2 未執行之前,被另外一個執行緒 A 搶佔了,這時 instance
已經是非 null 了(但卻沒有初始化),所以執行緒 A 會直接返回 instance
,然後被程式呼叫,就會報錯。
當然,這種情況是很難測試出來的,但是確實會存在這麼一個問題,所以我們必須解決它,解決方式也很簡單,就是 j 將
instance
加上volatile
關鍵字。
所以相對較完美的實現方式是:
/**
* @author eamon.zhang
* @date 2019-09-30 下午2:03
*/
public class LazyDoubleCheckSingleton {
private LazyDoubleCheckSingleton() {
}
private static volatile LazyDoubleCheckSingleton instance = null;
public static LazyDoubleCheckSingleton getInstance() {
// 這裡判斷是為了過濾不必要的同步加鎖,因為如果已經例項化了,就可以直接返回了
if (instance == null) {
// 如果未初始化,則對資源進行上鎖保護,待例項化完成之後進行釋放(注意,可能多個執行緒會同時進入)
synchronized (LazyDoubleCheckSingleton.class) {
// 這裡的if作用是:如果後面的程式在前面一個執行緒例項化完成之後拿到鎖,進入這個程式碼塊,
// 顯然,資源已經被例項化過了,所以需要進行判斷過濾
if (instance == null) {
instance = new LazyDoubleCheckSingleton();
}
}
}
return instance;
}
}
複製程式碼
測試程式碼見文末說明
靜態內部類懶漢式
上面的雙重鎖檢查形式的單例,對於日常開發來說,確實夠用了,但是在程式碼中使用synchronized
關鍵字 ,總歸是要上鎖,上鎖就會存在一個效能問題。難道就沒有更好的方案嗎?別說,還真有,我們從類初始化的角度來考慮,這就是這裡所要說到的靜態內部類的方式。
廢話不多說,直接看程式碼:
/**
*
* @author eamon.zhang
* @date 2019-09-30 下午2:55
*/
public class LazyInnerClassSingleton {
private LazyInnerClassSingleton() {
}
// 注意關鍵字final,保證方法不被重寫和過載
public static final LazyInnerClassSingleton getInstance() {
return LazyHolder.INSTANCE;
}
private static class LazyHolder {
// 注意 final 關鍵字(保證不被修改)
private static final LazyInnerClassSingleton INSTANCE = new LazyInnerClassSingleton();
}
}
複製程式碼
進行多執行緒測試:
pool-1-thread-9 : com.eamon.javadesignpatterns.singleton.lazy.inner.LazyInnerClassSingleton@88b7fa2
pool-1-thread-1 : com.eamon.javadesignpatterns.singleton.lazy.inner.LazyInnerClassSingleton@88b7fa2
pool-1-thread-6 : com.eamon.javadesignpatterns.singleton.lazy.inner.LazyInnerClassSingleton@88b7fa2
...
複製程式碼
結果都是同一個物件例項。
結論
這種方式即解決了餓漢式的記憶體浪費問題,也解決了synchronized
所帶來的效能問題
原理
利用的原理就是類的載入初始化順序:
- 當類不被呼叫的時候,類的靜態內部類是不會進行初始化的,這就避免了記憶體浪費問題;
- 當有方法呼叫
getInstance()
方法時,會先初始化靜態內部類,而靜態內部類中的成員變數是final
的,所以即便是多執行緒,其成員變數是不會被修改的,所以就解決了新增synchronized
所帶來的效能問題
首先感謝也恭喜大家能夠看到這裡,因為我想告訴你,上面所有的單例模式似乎還存在一點小問題 —— 暴力破壞。解決這一問題的方式就是下面提到的列舉型別單例。
至於緣由和為何列舉能夠解決這個問題,同樣,篇幅原因,我將在後面單獨開一篇文章來說明。
下面我們先來講講註冊式單例。
3、註冊式(登記式)單例
註冊式單例又稱為登記式單例,就是將每一個例項都登記到某一個地方,使用唯一的標識獲取例項。
註冊式單例有兩種寫法:一種為容器快取,一種為列舉登記。
先來看列舉式單例的寫法。
列舉單例
廢話少說,直接看程式碼,我們先建立EnumResource
類:
/**
* @author eamon.zhang
* @date 2019-09-30 下午3:53
*/
public class EnumResource {
}
複製程式碼
然後建立EnumSingleton
:
/**
* @author eamon.zhang
* @date 2019-09-30 下午3:42
*/
public enum EnumSingleton {
INSTANCE;
private Object instance;
EnumSingleton() {
instance = new EnumResource();
}
public Object getInstance() {
return instance;
}
}
複製程式碼
來看測試程式碼:
/**
* @author eamon.zhang
* @date 2019-09-30 下午3:47
*/
public class EnumSingletonTest {
@Test
public void test() {
try {
ConcurrentExecutor.execute(() -> {
EnumSingleton instance = EnumSingleton.INSTANCE;
System.out.println(instance.getInstance());
},10);
} catch (Exception e) {
e.printStackTrace();
}
}
}
複製程式碼
測試結果:
com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
複製程式碼
結果都一樣,說明列舉類單例是執行緒安全的,且是不可破壞的;在 JDK 列舉的語法特殊性,以及反射也為列舉保駕護航,讓列舉式單例成為一種比較優雅的實現。
列舉類單例也是《Effective Java》中所建議使用的。
容器式單例
註冊式單例還有另外一種寫法,利用容器快取,直接來看程式碼:
建立ContainerSingleton
類:
/**
* @author EamonZzz
* @date 2019-10-06 18:28
*/
public class ContainerSingleton {
private ContainerSingleton() {
}
private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();
public static Object getBean(String className) {
synchronized (ioc) {
if (!ioc.containsKey(className)) {
Object object = null;
try {
object = Class.forName(className).newInstance();
ioc.put(className,object);
} catch (Exception e) {
e.printStackTrace();
}
return object;
} else {
return ioc.get(className);
}
}
}
}
複製程式碼
測試程式碼:
@Test
public void test() {
try {
ConcurrentExecutor.execute(() -> {
Object bean = ContainerSingleton
.getBean("com.eamon.javadesignpatterns.singleton.container.Resource");
System.out.println(bean);
},5);
} catch (Exception e) {
e.printStackTrace();
}
}
複製程式碼
測試結果:
com.eamon.javadesignpatterns.singleton.container.Resource@42e7420f
com.eamon.javadesignpatterns.singleton.container.Resource@42e7420f
com.eamon.javadesignpatterns.singleton.container.Resource@42e7420f
com.eamon.javadesignpatterns.singleton.container.Resource@42e7420f
com.eamon.javadesignpatterns.singleton.container.Resource@42e7420f
複製程式碼
容器式寫法適用於建立例項非常多的情況,便於管理。但是,是非執行緒安全的。
其實 Spring 中也有相關容器史丹利的實現程式碼,比如 AbstractAutowireCapableBeanFactory
介面
至此,註冊式單例介紹完畢。
五、拓展
ThreadLocal 執行緒單例
ThreadLocal 不能保證其建立的物件是唯一的,但是能保證在單個執行緒中是唯一的,並且在單個執行緒中是天生的執行緒安全。
看程式碼:
/**
* @author EamonZzz
* @date 2019-10-06 21:40
*/
public class ThreadLocalSingleton {
private ThreadLocalSingleton() {
}
private static final ThreadLocal<ThreadLocalSingleton> instance = ThreadLocal.withInitial(ThreadLocalSingleton::new);
public static ThreadLocalSingleton getInstance() {
return instance.get();
}
}
複製程式碼
測試程式:
@Test
public void test() {
System.out.println("-------------- 單執行緒 start ---------");
System.out.println(ThreadLocalSingleton.getInstance());
System.out.println(ThreadLocalSingleton.getInstance());
System.out.println(ThreadLocalSingleton.getInstance());
System.out.println(ThreadLocalSingleton.getInstance());
System.out.println(ThreadLocalSingleton.getInstance());
System.out.println("-------------- 單執行緒 end ---------");
System.out.println("-------------- 多執行緒 start ---------");
try {
ConcurrentExecutor.execute(() -> {
ThreadLocalSingleton singleton = ThreadLocalSingleton.getInstance();
System.out.println(Thread.currentThread().getName() + " : " + singleton);
},5);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("-------------- 多執行緒 end ---------");
}
複製程式碼
測試結果:
-------------- 單執行緒 start ---------
com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@1374fbda
com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@1374fbda
com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@1374fbda
com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@1374fbda
com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@1374fbda
-------------- 單執行緒 end ---------
-------------- 多執行緒 start ---------
pool-1-thread-5 : com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@2f540d92
pool-1-thread-1 : com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@3ef7ab4e
pool-1-thread-2 : com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@604ffe2a
pool-1-thread-3 : com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@50f41c9f
pool-1-thread-4 : com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@40821a7a
-------------- 多執行緒 end ---------
複製程式碼
從測試結果來看,我們不難發現,在主執行緒中無論呼叫多少次,獲得到的例項都是同一個;在多執行緒環境下,每個執行緒獲取到了不同的例項。
所以,在單執行緒環境中,ThreadLocal 可以達到單例的目的。這實際上是以空間換時間來實現執行緒間隔離的。
六、總結
單例模式可以保證記憶體裡只有一個例項,減少了記憶體的開銷;可避免對資源的浪費。
單例模式看起來非常簡單,實現起來也不難,但是在面試中卻是一個高頻的面試題。希望大家能夠徹底理解。
本篇文章所涉及的原始碼: