簡介

物件建立型模式

核心：一個類只生成唯一例項物件，構造方法私有化禁止外部建立物件。GoF對單例模式的定義是：保證一個類只有一個例項存在，同時提供能對該例項加以訪問的全域性訪問方法（靜態方法）
總結就是如下：
- 類中唯一例項引用
- 構造方法私有
- 一個靜態方法訪問該例項

為什麼使用單例模式

• 共享資源
• 節省物件的建立時間等等

典型單例模式

• 餓漢式
• 懶漢式（飽漢）（多執行緒不能保證單例模式）
• 雙重檢查
• 靜態內部類實現

多種實現方式

餓漢式

• 優點：多執行緒中能夠保證單例
• 缺點：類一載入就例項化並且一直存在，浪費資源
• 推薦：可以使用

package
 
 com.mym.designmodel.singleton;

/**
 * 餓漢單例模式
 */
public class ESingleton {
    public static ESingleton eSingleton = new ESingleton();

    private ESingleton(){}

    public static ESingleton getSingleton(){
        return eSingleton;
    }
}

飽漢式

• 優點：能夠懶載入
• 缺點：多執行緒中不能保證單例
• 推薦：不推薦使用

package com.mym.designmodel.singleton;

/**
 * 飽漢模式
 */
 

public class BSingleton {

    private static BSingleton bSingleton = null;

    private BSingleton(){}

    public static BSingleton getSingleton(){
        if(bSingleton == null){
            bSingleton  = new BSingleton();
        }
        return bSingleton;
    }

}

飽漢式執行緒安全

• 優點：能夠懶載入，保證了多執行緒中的單例
• 缺點：阻塞模式，多執行緒執行效率較低
• 推薦：不推薦使用

package com.mym.designmodel.singleton;

/**
 * 飽漢模式升級1
 */
public class BSingletonUp1 {

    private static BSingletonUp1 bSingletonUp1 = null;

    private BSingletonUp1(){}

    //阻塞模式
    public static synchronized  BSingletonUp1 getSingleton(){
        if(bSingletonUp1 == null){
            bSingletonUp1  = new BSingletonUp1();
        }
        return bSingletonUp1;
    }
}

雙重檢查模式單例實現

• 優點：能夠懶載入、保證多執行緒中的單例、微阻塞
• 缺點：第一次訪問仍然是阻塞的
• 推薦：推薦使用，效率可以

package com.mym.designmodel.singleton;

/**
 * 雙重檢查模式
 */
public class DoubleCheckSingleton {

    private static DoubleCheckSingleton doubleCheckSingleton = null;

    private DoubleCheckSingleton(){}

    //雙重檢查 阻塞模式
    public static DoubleCheckSingleton getSingleton(){
        if(doubleCheckSingleton == null){
            synchronized (DoubleCheckSingleton.class){
                if(doubleCheckSingleton == null){
                    doubleCheckSingleton  = new DoubleCheckSingleton();
                }
            }
        }
        return doubleCheckSingleton;
    }
}

靜態內部類實現單例模式

• 優點：懶載入、多執行緒保證單例、非阻塞、效率高
• 缺點：較其他實現方式多了一個類資源（靜態內部類也是一個類），不過影響不大
• 推薦：非常推薦，高效率

package com.mym.designmodel.singleton;

/**
 * 飽漢模式：靜態內部類實現，非阻塞，推薦使用
 */
public class Singleton {

    private Singleton(){}

    private static class InnerClass{
        private final static Singleton instance = new Singleton();
    }

    public static Singleton getSingleton(){
        return InnerClass.instance;
    }

}

測試

本測試著力於是否保證單例。其他執行緒安全、執行效率，筆者就不貼程式碼了

package com.mym.designmodel.singleton;

/**
 * 測試
 */
public class MainClass {

    public static void main(String[] args) {
        ESingleton eSingleton1 = ESingleton.getSingleton();
        ESingleton eSingleton2 = ESingleton.getSingleton();
        System.out.println("【ESingleton】是否為同一例項：" + (eSingleton1 == eSingleton2));

        BSingleton bSingleton1 = BSingleton.getSingleton();
        BSingleton bSingleton2 = BSingleton.getSingleton();
        System.out.println("【BSingleton】是否為同一例項：" + (bSingleton1 == bSingleton2));

        BSingletonUp1 bSingletonUp1 = BSingletonUp1.getSingleton();
        BSingletonUp1 bSingletonUp2 = BSingletonUp1.getSingleton();
        System.out.println("【BSingletonUp1】是否為同一例項：" + (bSingletonUp1 == bSingletonUp2));

        DoubleCheckSingleton doubleCheckSingleton1 = DoubleCheckSingleton.getSingleton();
        DoubleCheckSingleton doubleCheckSingleton2 = DoubleCheckSingleton.getSingleton();
        System.out.println("【DoubleCheckSingleton】是否為同一例項：" + (doubleCheckSingleton1 == doubleCheckSingleton2));

        Singleton singleton1 = Singleton.getSingleton();
        Singleton singleton2 = Singleton.getSingleton();
        System.out.println("【Singleton】是否為同一例項：" + (singleton1 == singleton2));
    }
}

輸出結果：

【ESingleton】是否為同一例項：true
【BSingleton】是否為同一例項：true
【BSingletonUp1】是否為同一例項：true
【DoubleCheckSingleton】是否為同一例項：true
【Singleton】是否為同一例項：true

單例模式的擴充套件

單例目的是節約資源。難點在於執行緒安全和效率。而單例不止是如上的實現，在java體系中，最為模範的單例模式就是列舉類，而最常用到的單例模式也還有八個基本資料型別對應的封裝類：Integer、Long、Float…檢視原始碼即可知道，他們內部都是單例且不可修改的：

Integer a = new Integer(2);
Integer b = new Integer(2);
System.out.println(a == b);

結果為false。

原始碼：Integer的內部

    /**
     * The value of the {@code Integer}.
     *
     * @serial
     */
    private final int value;

    /**
     * Constructs a newly allocated {@code Integer} object that
     * represents the specified {@code int} value.
     *
     * @param   value   the value to be represented by the
     *                  {@code Integer} object.
     */
    public Integer(int value) {
        this.value = value;
    }

由封裝類可知，實際上使用final也可以實現偽單例模式。