Java設計模式系列：單例設計模式

介紹

所謂類的單例設計模式，就是采取一定的方法保證在整個的軟件系統中，對某個類只能存在一個對象實例，并且該類只提供一個取得其對象實例的方法（靜態方法）

比如 Hibernate 的 SessionFactory，它充當數據存儲源的代理，并負責創建 Session 對象。SessionFactory 并不是輕量級的，一般情況下，一個項目通常只需要一個 SessionFactory 就夠，這是就會使用到單例模式

八種方式

1）餓漢式（靜態常量）
2）餓漢式（靜態代碼塊）
3）懶漢式（線程不安全）
4）懶漢式（線程安全，同步方法）
5）懶漢式（線程不安全，同步代碼塊）
6）雙重檢查
7）靜態內部類
8）枚舉

1、餓漢式（靜態常量）

1）構造器私有化（防止外部 new）
2）類的內部創建對象
3）向外暴露一個靜態的公共方法 getInstance

package com.mcode.api.singleton.type1;/*** ClassName: SingletonTest01* Package: com.mcode.api.singleton.type1* Description:** @Author: robin* @Create: 2019/11/22 - 9:41 PM* @Version: v1.0*/
public class SingletonTest01 {public static void main(String[] args) {Singleton instance = Singleton.getInstance();Singleton instance1 = Singleton.getInstance();System.out.println(instance == instance1); //trueSystem.out.println("instance.hashCode=" + instance.hashCode());System.out.println("instance.hashCode=" + instance1.hashCode());}
}//餓漢式（靜態變量）
class Singleton {// 1、構造器私有化private Singleton() {}// 2、類的內部創建對象private static final Singleton instance = new Singleton();// 3、向外暴露一個靜態的公共方法public static Singleton getInstance() {return instance;}
}

優缺點

1）優點：這種寫法比較簡單，就是在類裝載的時候就完成實例化。避免了線程同步問題
2）缺點：在類裝載的時候就完成實例化，沒有達到 Lazy Loading 的效果。如果從始至終從未使用過這個實例，則會造成內存的浪費
3）這種方式基于 classloder 機制避免了多線程的同步問題。不過，instance 在類裝載時就實例化，在單例模式中大多數都是調用getlnstance 方法，但是導致類裝載的原因有很多種，因此不能確定有其他的方式（或者其他的靜態方法）導致類裝載，這時候初始化 instance 就沒有達到 Lazy loading 的效果
4）結論：這種單例模式可用，可能造成內存浪費

2、餓漢式（靜態代碼塊）

1）構造器私有化
2）類的內部聲明對象
3）在靜態代碼塊中創建對象
4）向外暴露一個靜態的公共方法

public class Singleton {// 1、構造器私有化private Singleton() {}// 2、類的內部聲明對象private static Singleton instance;// 3、在靜態代碼塊中創建對象static {instance = new Singleton();}// 4、向外暴露一個靜態的公共方法public static Singleton getInstance() {return instance;}
}

優缺點

1）這種方式和上面的方式其實類似，只不過將類實例化的過程放在了靜態代碼塊中，也是在類裝載的時候，就執行靜態代碼塊中的代碼，初始化類的實例。優缺點和上面是一樣的。
2）結論：這種單例模式可用，但是可能造成內存浪費

3、懶漢式（線程不安全）

1）構造器私有化
2）類的內部創建對象
3）向外暴露一個靜態的公共方法，當使用到該方法時，才去創建 instance

// 1、構造器私有化
private Singleton() {
}// 2、類的內部聲明對象
private static Singleton instance;// 3、向外暴露一個靜態的公共方法，當使用到該方法時，才去創建 instance
public static Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;
}

優缺點

1）起到了 Lazy Loading 的效果，但是只能在單線程下使用
2）如果在多線程下，一個線程進入了判斷語句塊，還未來得及往下執行，另一個線程也通過了這個判斷語句，這時便會產生多個實例
3）結論：在實際開發中，不要使用這種方式

4、懶漢式（線程安全，同步方法）

1）構造器私有化
2）類的內部創建對象
3）向外暴露一個靜態的公共方法，加入同步處理的代碼，解決線程安全問題

public class Singleton {// 1、構造器私有化private Singleton() {}// 2、類的內部聲明對象private static Singleton instance;// 3、向外暴露一個靜態的公共方法，加入同步處理的代碼，解決線程安全問題public static synchronized Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}
}

優缺點

1）解決了線程不安全問題
2）效率太低了，每個線程在想獲得類的實例時候，執行getlnstance()方法都要進行同步。而其實這個方法只執行一次實例化代碼就夠了，后面的想獲得該類實例，直接return就行了。方法進行同步效率太低
3）結論：在實際開發中，不推薦使用這種方式

5、懶漢式（線程不安全，同步代碼塊）

1）構造器私有化
2）類的內部創建對象
3）向外暴露一個靜態的公共方法，加入同步處理的代碼塊

public class Singleton {// 1、構造器私有化private Singleton() {}// 2、類的內部聲明對象private static Singleton instance;// 3、向外暴露一個靜態的公共方法，加入同步處理的代碼，解決線程安全問題public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {instance = new Singleton();}}return instance;}
}

優缺點

1）這種方式，本意是想對第四種實現方式的改進，因為前面同步方法效率太低，改為同步產生實例化的的代碼塊
2）但是這種同步并不能起到線程同步的作用。跟第3種實現方式遇到的情形一致，假如一個線程進入了判斷語句塊，還未來得及往下執行，另一個線程也通過了這個判斷語句，這時便會產生多個實例
3）結論：在實際開發中，不能使用這種方式

6、雙重檢查

1）構造器私有化
2）類的內部創建對象，同時用volatile關鍵字修飾修飾
3）向外暴露一個靜態的公共方法，加入同步處理的代碼塊，并進行雙重判斷，解決線程安全問題

public class Singleton {// 1、構造器私有化private Singleton() {}// 2、類的內部聲明對象，同時用`volatile`關鍵字修飾修飾private static volatile Singleton instance;// 3、向外暴露一個靜態的公共方法，加入同步處理的代碼塊，并進行雙重判斷，解決線程安全問題public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {if (instance == null) {instance = new Singleton();}}}return instance;}
}

優缺點

1）Double-Check 概念是多線程開發中常使用到的，我們進行了兩次檢查，這樣就可以保證線程安全了
2）這樣實例化代碼只用執行一次，后面再次訪問時直接 return 實例化對象，也避免的反復進行方法同步
3）線程安全；延遲加載；效率較高
4）結論：在實際開發中，推薦使用這種單例設計模式

7、靜態內部類

1）構造器私有化
2）定義一個靜態內部類，內部定義當前類的靜態屬性
3）向外暴露一個靜態的公共方法

public class Singleton {// 1、構造器私有化private Singleton() {}// 2、定義一個靜態內部類，內部定義當前類的靜態屬性private static class SingletonInstance {private static final Singleton instance = new Singleton();}// 3、向外暴露一個靜態的公共方法public static Singleton getInstance() {return SingletonInstance.instance;}
}

優缺點

1）這種方式采用了類裝載的機制，來保證初始化實例時只有一個線程
2）靜態內部類方式在 Singleton 類被裝載時并不會立即實例化，而是在需要實例化時，調用getlnstance方法，才會裝載Singletonlnstance 類，從而完成 Singleton 的實例化
3）類的靜態屬性只會在第一次加載類的時候初始化，JVM幫助我們保證了線程的安全性，在類進行初始化時，別的線程是無法進入的
4）優點：避免了線程不安全，利用靜態內部類特點實現延遲加載，效率高
5）結論：推薦使用

8、枚舉

public enum Singleton {INSTANCE;public void sayHello() {System.out.println("Hello World");}
}

優缺點

1）這借助 JDK1.5 中添加的枚舉來實現單例模式。不僅能避免多線程同步問題，而且還能防止反序列化重新創建新的對象
2）這種方式是 Effective Java 作者 Josh Bloch 提倡的方式
3）結論：推薦使用

JDK 源碼分析

JDK中 java.lang.Runtime 就是經典的單例模式

注意事項和細節說明

1）單例模式保證了系統內存中該類只存在一個對象，節省了系統資源，對于一些需要頻繁創建銷毀的對象，使用單例模式可以提高系統性能
2）當想實例化一個單例類的時候，必須要記住使用相應的獲取對象的方法，而不是使用 new
3）單例模式使用的場景：需要頻繁的進行創建和銷毀的對象、創建對象時耗時過多或耗費資源過多但又經常用到的對象（即：重量級對象）、工具類對象、頻繁訪問數據庫或文件的對象（比如數據源、session 工廠等）

雖然上述提到的概念中，將雙重檢查、靜態內部類、枚舉三種方式的單例模式單獨列舉出來說明，但個人覺得本質也可以歸類到餓漢式和懶漢式中；另外，同步代碼塊雖然上述中歸類到線程安全，實際上并不是線程安全的

總結如下