設計模式 | 詳解單例模式（餓漢式、懶漢式、靜態內部類、枚舉、JDK源碼剖析） 一、單例模式介紹 二、單例模式的七種方式 三、單例模式在JDK應用的源碼分析 四、單例模式注意事項和細節說明

一、單例模式介紹

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

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

二、單例模式的七種方式

單例模式有以下七種方式

• 餓漢式（靜態常量）
• 餓漢式（靜態代碼塊）
• 懶漢式（線程不安全）
• 懶漢式（線程安全，同步方法）
• 懶漢式之雙重檢查（線程安全，同步代碼塊）
• 靜態內部類
• 枚舉

1、餓漢式（靜態常量）

步驟如下：

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

package com.cxc.singleton.type1;

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
    }
}

/**
 * 餓漢式（靜態變量）
 */
class Singleton{
    //構造器私有化
    private Singleton(){}

    //在類內部創建對象實例
    private final static Singleton instance = new Singleton();

    //提供一個公有的靜態方法，返回實例對象
    public static Singleton getInstance(){
        return instance;
    }
}

這種方式的優點是寫法簡單，在類裝載的時候就完成了實例化，避免了線程同步問題。
而缺點有以下：

• 在類裝載的時候就完成實例化，沒有達到懶加載（Lazy Loading）的效果。如果從始至終從未使用過這個實力，則會造成內存的浪費。
• 這種方式基於classloader機制避免了多線程的同步問題，不過，instance在類裝載時就實例化，在單例模式中大多數都是調用getInstance方法，但是導致類裝載的原因有很多種，因此不能確定有其他的方式（或者其他的靜態方法）導致類裝載，這時候切換instance就沒有達到懶加載的效果。
• 這種單例模式可用，但是可能造成內存浪費。

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

與第一種方式一樣，僅僅只是將實例化對象放入一個靜態代碼塊而已。

package com.cxc.singleton.type2;

public class SingletonTest02 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
    }
}

/**
 * 餓漢式（靜態代碼塊）
 */
class Singleton{

    //構造器私有化
    private Singleton(){}

    //對象實例
    private static Singleton instance ;

    //在靜態代碼塊中實例化對象
    static{
        instance = new Singleton();
    }

    //提供一個公有的靜態方法，返回實例對象
    public static Singleton getInstance(){
        return instance;
    }
}

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

先不實例化對象，等到需要用到的時候再去實例化：

package com.cxc.singleton.type3;

public class SingletonTest03 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton);
    }
}

/**
 * 懶漢式（線程不安全）
 */
class Singleton{
    private static Singleton instance;

    private Singleton(){}

    //提供一個靜態的公有方法，當使用到該方法時，纔去實例化
    public static Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

優缺點：

• 起到了懶加載的效果，但是隻能在單線程下使用。
• 如果在多線程下，一個線程進入了if(singleton == null)判斷語句塊，還未來得及往下執行，另一個線程也通過了這個判斷語句，這時就會產生多個實例。所以在多線程環境下不可使用這種方式。

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

在方法上加入synchronized同步關鍵字：

package com.cxc.singleton.type4;

public class SingletonTest04 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton);
    }
}

/**
 * 懶漢式（線程安全,同步方法）
 */
class Singleton{
    private static Singleton instance;

    private Singleton(){}

    //提供一個靜態的公有方法，加入了同步處理的代碼，解決線程安全問題
    public static synchronized Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

優缺點：

• 解決了線程不安全問題。
• 效率太低了，每個線程在想獲得類的實例的時候，執行getInstance()方法都要進行同步，而其實這個方法只執行一次實例化代碼就夠了，後面的想獲得該類實例，直接return就行了，方法進行同步效率太低。

5、懶漢式之雙重檢查（線程安全，同步代碼塊）

在方法裏面先判空後，再使用synchronized關鍵字的同步代碼塊（鎖的是類），如果再一次判空（這裏必須雙重判空，不然會有線程安全問題）：

package com.cxc.singleton.type5;

public class SingletonTest05 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton);
    }
}

/**
 * 懶漢式（線程安全,同步代碼塊）
 */
class Singleton{
    private static volatile Singleton instance;

    private Singleton(){}

    //提供一個靜態的公有方法
    public static Singleton getInstance(){
        if (instance == null){
            synchronized(Singleton.class){
                //雙重判定
                if (instance == null){
                    instance = new Singleton();
                }
            }

        }
        return instance;
    }
}

對象加上了volatile關鍵字是爲了保證變量的可見性，防止指令重排序。

6、靜態內部類

這種方式利用到了靜態內部類的特性：

靜態內部類在外部類裝載時並不是立即被實例化，而是需要使用到靜態內部類時纔會被加載。

package com.cxc.singleton.type6;

public class SingletonTest06 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton);
    }
}

/**
 * 靜態內部類
 */
class Singleton{
    private static volatile Singleton instance;

    private Singleton(){}

    //寫一個靜態內部類，該類中有一個靜態屬性
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }

    //提供一個靜態的公有方法
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

優缺點：

• 這種方式採用了類裝載的機制來保證初始化實例時只有一個線程。
• 靜態內部類這種方式在Singleton類被裝載時並不是立即實例化，而是在需要實例化時，調用getInstance方法用到了內部類，纔會裝載SingletonInstance類，從而完成Singleton的實例化。
• 類的靜態屬性只會在第一次加載類的時候初始化，所以在這裏，JVM幫助我們保證了線程的安全性，在類進行初始化時，別的線程是無法進入的。
• 避免了線程不安全，利用靜態內部類特點實現延遲加載，效率高。極力推薦。

7、枚舉

package com.cxc.singleton.type7;

public class SingletonTest07 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.INSTANCE;
        singleton.sayOk();
    }
}

/**
 * 使用枚舉可以實現單例模式
 */
enum Singleton{
    INSTANCE;

    public void sayOk(){
        System.out.println("ok~");
    }
}

三、單例模式在JDK應用的源碼分析

在JDK的java.lang.Runtime類中就用到了單例模式，Runtime的部分源碼如下：

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    ......
}

Runtime類定義了currentRuntime對象，然後直接實例化，對其構造方法私有化。這是屬於餓漢式單例模式。

四、單例模式注意事項和細節說明

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