你敢說本身瞭解單例模式?

時間  2020-08-21
標籤 敢說 本身 瞭解 模式 简体版
原文   原文鏈接

1、背景

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

2、基本概念

1.爲何要使用單例模式？數據庫

　　在咱們平常的工做中，不少對象一般佔用很是重要的系統資源，好比：IO處理，數據庫操做等，那咱們必需要限制這些對象只有且始終使用一個公用的實例，即單例。設計模式

2.單例模式的實現方式安全

  • 構造函數私有化，防止其餘類生成惟一公用實例外的實例。且
  • 單例類應該被定義爲final，也就是說單例類不能被繼承，由於若是容許繼承那子類就均可以建立實例，違背了類惟一實例的初衷。
  • 類中一個靜態變量來保存單實例的引用。
  • 一個共有的靜態方法來獲取單實例的引用。

3.單例模式的UML類圖多線程

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

  • 餓漢式：一開始就建立好實例，每次調用直接返回，經典的「拿空間換時間」。
  • 懶漢式：延遲加載，第一次調用的時候才加載，而後返回，之後的每次的調用就直接返回。經典「拿時間換空間」,多線程環境下要注意解決線程安全的問題。
  • 登記式：對一組單例模式進行的維護，主要是在數量上的擴展，經過線程安全的map把單例存進去，這樣在調用時，先判斷該單例是否已經建立，是的話直接返回，不是的話建立一個登記到map中，再返回。

3、餓漢式---代碼實現

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.測試結果測試

4、懶漢式---代碼實現

1.單例類spa

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,而後建立了好幾遍實例，不符合單例的思想，咱們能夠對它進行改進。

5、改進懶漢式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.測試結果

6、改進懶漢式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.測試結果

7、登記式--代碼實現

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),有好的解決方案的博友能夠討論指教~

8、總結

　　通過本文，咱們就搞明白了什麼叫單例模式，如何優雅的實現經典的單例模式，如何進行拓展和開發具備線程安全的單例模式。對於咱們之後的開發很是有幫助，也讓咱們更加了解單例模式。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程