你敢說自己瞭解單例模式?

一、背景

　　最近在學習設計模式，在看到單例模式的時候，我一開始以為直接很瞭解單例模式了，實現起來也很簡單，但是實際上單例模式有著好幾個變種，並且多執行緒中涉及到執行緒安全問題，那麼本文我們就來好好聊聊單例模式，說一下經典三種實現方式：餓漢式、懶漢式、登記式。並且解決掉多執行緒中可能出現的執行緒安全問題。

二、基本概念

1.為什麼要使用單例模式？

　　在我們日常的工作中，很多物件通常佔用非常重要的系統資源，比如：IO處理，資料庫操作等，那我們必須要限制這些物件只有且始終使用一個公用的例項，即單例。

2.單例模式的實現方式

• 建構函式私有化，防止其他類生成唯一公用例項外的例項。且
• 單例類應該被定義為final，也就是說單例類不能被繼承，因為如果允許繼承那子類就都可以建立例項，違背了類唯一例項的初衷。
• 類中一個靜態變數來儲存單例項的引用。
• 一個共有的靜態方法來獲取單例項的引用。

3.單例模式的UML類圖

4.單例模式的經典實現方式

• 餓漢式：一開始就建立好例項，每次呼叫直接返回，經典的“拿空間換時間”。
• 懶漢式：延遲載入，第一次呼叫的時候才載入，然後返回，以後的每次的呼叫就直接返回。經典“拿時間換空間”,多執行緒環境下要注意解決執行緒安全的問題。
• 登記式：對一組單例模式進行的維護，主要是在數量上的擴充套件，通過執行緒安全的map把單例存進去，這樣在呼叫時，先判斷該單例是否已經建立，是的話直接返回，不是的話建立一個登記到map中，再返回。

三、餓漢式---程式碼實現

1.單例類

package com.hafiz.designPattern.singleton;

/**
 * Desc: 單例模式-餓漢式
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton1 {

    // 建立全域性靜態變數，保證只有一個例項
    private static volatile Singleton1 instance  = new Singleton1();

    private Singleton1() {
        // 建構函式私有化
        System.out.println("--呼叫餓漢式單例模式的建構函式--");
    }

    public static Singleton1 getInstance() {
        System.out.println("--呼叫餓漢式單例模式的靜態方法返回例項--");
        return instance;
    }
}

2.測試類

public class DesignPatternTest {

    @Test
    public void testSingleton1() {
        System.out.println("-----------------測試餓漢式單例模式開始--------------");
        Singleton1 instance1 = Singleton1.getInstance();
        System.out.println("第二次獲取例項");
        Singleton1 instance2 = Singleton1.getInstance();
        System.out.println("instance1和instance2是否為同一例項?" + (instance1 == instance2));
        System.out.println("-----------------測試餓漢式單例模式結束--------------");
    }
}

3.測試結果

四、懶漢式---程式碼實現

1.單例類

package com.hafiz.designPattern.singleton;

/**
 * Desc:單例模式-懶漢式
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton2 {

    // 建立全域性靜態變數，保證只有一個例項
    private static Singleton2 instance = null;

    // 建構函式私有化
    private Singleton2() {
        System.out.println("--呼叫懶漢式單例模式的構造方法--");
    }

    public static Singleton2 getInstance() {
        System.out.println("--呼叫懶漢式單例模式獲取例項--");
        if (instance == null) {
            System.out.println("--懶漢式單例例項未建立,先建立再返回--");
            instance = new Singleton2();
        }
        return instance;
    }
}

2.測試類

public class DesignPatternTest {

    @Test
    public void testSingleton2() {
        System.out.println("-----------------測試懶漢式單例模式開始--------------");
        Singleton2 instance1 = Singleton2.getInstance();
        System.out.println("第二次獲取例項");
        Singleton2 instance2 = Singleton2.getInstance();
        System.out.println("instance1和instance2是否為同一例項?" + (instance1 == instance2));
        System.out.println("-----------------測試懶漢式單例模式結束--------------");
    }
}

3.測試結果

細心的同學已經發現，這種實現方式，在多執行緒的環境中，是有執行緒安全安全問題的，有可能兩個或多個執行緒判斷instance都為null,然後建立了好幾遍例項，不符合單例的思想，我們可以對它進行改進。

五、改進懶漢式1---程式碼實現

原理：使用JDK的synchronized同步程式碼塊來解決懶漢式執行緒安全問題。

1.單例類

package com.hafiz.designPattern.singleton;

/**
 * Desc:單例模式-懶漢式
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton2 {

    // 建立全域性靜態變數，保證只有一個例項
    private static Singleton2 instance = null;

    // 建構函式私有化
    private Singleton2() {
        System.out.println("--呼叫懶漢式單例模式的構造方法--");
    }

    public static Singleton2 getInstance() {
        System.out.println("--呼叫懶漢式單例模式獲取例項--");
　　　　　if (instance != null) {
　　　　　　　　System.out.println("--懶漢式單例例項已經建立,直接返回--");
            　return instance;
　　　　　}
        synchronized (Singleton2.class) {
        　　 if (instance == null) {
            　　System.out.println("--懶漢式單例例項未建立,先建立再返回--");
            　　instance = new Singleton2();
        　　 }
        }
        return instance;
    }
} 

2.測試結果

六、改進懶漢式2---程式碼實現

原理：使用JVM隱含的同步和類級內部類來解決，JVM隱含的同步解決了多執行緒情況下執行緒安全的問題，類級內部類解決只有使用的時候才載入（延遲載入）的問題。

1.JVM隱含的同步有哪些？

• 靜態初始化器(在靜態欄位上或static{}靜態程式碼塊的初始化器)初始化資料時
• 訪問final欄位時
• 在建立執行緒之前建立物件時
• 執行緒可以看見它將要處理的物件時

2.什麼是類級內部類？

• 有static修飾的成員式內部類。沒有static修飾的成員式內部類叫物件級內部類。
• 類級內部類相當於其外部類的static成分，他的物件與外部類物件間不存在依賴關係，因此可直接建立，而物件級內部類的例項，是繫結在外部物件例項中的。
• 類級內部類中，可以定義靜態的方法。在靜態的方法中只能夠引用外部類的中的靜態成員方法或者成員變數
• 類級內部類相當於其外部類的成員，只有在第一次被使用的時候才會被裝載

3.單例類

package com.hafiz.designPattern.singleton;

/**
 * Desc:單例模式-改進懶漢式
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton3 {
    private static class Singleton4 {
        private static Singleton3 instance;
        static {
            System.out.println("--類級內部類被載入--");
            instance = new Singleton3();
        }
        private Singleton4() {
            System.out.println("--呼叫類級內部類的建構函式--");
        }
    }
    private Singleton3() {
        System.out.println("--呼叫建構函式--");
    }
    public static Singleton3 getInstance() {
        System.out.println("--開始呼叫共有方法返回例項--");
        Singleton3 instance;
        System.out.println("---------------------------");
        instance = Singleton4.instance;
        System.out.println("返回單例");
        return instance;
    }
}

4.測試類

package com.hafiz.www;

import com.hafiz.designPattern.observer.ConcreteObserver;
import com.hafiz.designPattern.observer.ConcreteSubject;
import com.hafiz.designPattern.singleton.Singleton1;
import com.hafiz.designPattern.singleton.Singleton2;
import com.hafiz.designPattern.singleton.Singleton3;
import com.hafiz.designPattern.singleton.Singleton4;
import com.hafiz.designPattern.singleton.Singleton4Child1;
import com.hafiz.designPattern.singleton.SingletonChild2;
import org.junit.Test;

/**
 * Desc:設計模式demo單元測試類
 * Created by hafiz.zhang on 2017/7/27.
 */
public class DesignPatternTest {

    @Test
    public void testSingleton3() {
        System.out.println("-----------------測試改進懶漢式單例模式開始--------------");
        Singleton3 instance1 = Singleton3.getInstance();
        System.out.println("第二次獲取例項");
        Singleton3 instance2 = Singleton3.getInstance();
        System.out.println("instance1和instance2是否為同一例項?" + (instance1 == instance2));
        System.out.println("-----------------測試改進懶漢式單例模式結束--------------");
    }
}

5.測試結果

七、登記式--程式碼實現

1.基類

package com.hafiz.designPattern.singleton;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Desc: 單例模式-登記式
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton4 {

    private static Map<String, Singleton4> map = new ConcurrentHashMap<>();

    protected Singleton4() {
        System.out.println("--私有化建構函式被呼叫--");
    }

    public static Singleton4 getInstance(String name) {
        if (name == null) {
            name = Singleton4.class.getName();
            System.out.println("--name為空，預設賦值為：--" + Singleton4.class.getName());
        }
        if (map.get(name) != null) {
            System.out.println("name對應的值存在，直接返回");
            return map.get(name);
        }
        System.out.println("name對應的值不存在，先建立，再返回");
        try {
            Singleton4 result = (Singleton4)Class.forName(name).newInstance();
            map.put(name, result);
            return result;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    public Map<String, Singleton4> getMap() {
        return map;
    }
}

2.子類1

package com.hafiz.designPattern.singleton;

/**
 * Desc:
 * Created by hafiz.zhang on 2017/9/26.
 */
public class Singleton4Child1 extends Singleton4 {

    public static Singleton4Child1 getInstance() {
        return (Singleton4Child1) Singleton4.getInstance("com.hafiz.designPattern.singleton.Singleton4Child1");
    }
}

3.子類2

package com.hafiz.designPattern.singleton;

/**
 * Desc:
 * Created by hafiz.zhang on 2017/9/26.
 */
public class SingletonChild2 extends Singleton4 {

    public static SingletonChild2 getInstance() {
        return (SingletonChild2) Singleton4.getInstance("com.hafiz.designPattern.singleton.SingletonChild2");
    }
}

4.測試類

public class DesignPatternTest {

    @Test
    public void testSingleton4() {
        System.out.println("-----------------測試登記式單例模式開始--------------");
        System.out.println("第一次取得例項");
        Singleton4 instance1 = Singleton4.getInstance(null);
        System.out.println("res:" + instance1);
        System.out.println("第二次獲取例項");
        Singleton4Child1 instance2 = Singleton4Child1.getInstance();
        System.out.println("res:" + instance2);
        System.out.println("第三次獲取例項");
        SingletonChild2 instance3 = SingletonChild2.getInstance();
        System.out.println("res:" + instance3);
        System.out.println("第四次獲取例項");
        SingletonChild2 instance4 = new SingletonChild2();
        System.out.println("res:" + instance4);
        System.out.println("輸出父類Map中所有的單例");
        Map<String, Singleton4> map = instance1.getMap();
        for (Map.Entry<String, Singleton4> item : map.entrySet()) {
            System.out.println("map-item:" + item.getKey() + "=" + item.getValue());
        }
        System.out.println("instance1和instance2是否為同一例項?" + (instance1 == instance2));
        System.out.println("-----------------測試登記式單例模式結束--------------");
    }
}

5.測試結果

該解決方案的缺點：基類的建構函式對子類公開了(protected),有好的解決方案的博友可以討論指教~

八、總結

　　經過本文，我們就搞明白了什麼叫單例模式，如何優雅的實現經典的單例模式，如何進行擴充和開發具有執行緒安全的單例模式。對於我們以後的開發非常有幫助，也讓我們更加了解單例模式。