2. 程式人生 > 實用技巧 >設計模式之單例模式（Singleton Pattern）深入淺出

設計模式之單例模式（Singleton Pattern）深入淺出

阿新 • • 發佈：2020-09-08

單例模式介紹：單例模式是指確保一個類在任何情況下都絕對只有一個例項，並且提供一個全域性的訪問點。隱藏其所有構造方法，屬於創新型模式。

常見的單例有：ServletContext、ServletConfig、ApplicationContext、DBPool

單例模式的優點：

  • 在記憶體中只有一個例項，減少記憶體開銷。
  • 可以避免對資源的佔用
  • 設定全域性訪問點，嚴格控制訪問

單例模式的缺點：

  • 沒有介面，擴充套件困難
  • 如果要擴充套件單例物件，只有修改程式碼，沒有其他捷徑

以下是單例模式的種類及優缺點分析

餓漢式單例

在單例類首次載入時就建立例項

第一種寫法：

public class HungrySingleton {

    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }
}

　第二種寫法：　

public class HungryStaticSingleton {

    private static final HungryStaticSingleton hungrySingleton;

    static {
        hungrySingleton = new HungryStaticSingleton();
    }

    private HungryStaticSingleton() {
    }

    public static HungryStaticSingleton getInstance() {
        return hungrySingleton;
    }
}

　　缺點：單例例項在類裝載時就構建，浪費資源空間

懶漢式單例

一、懶漢式第一種：

首先先簡單實現以下

public class LazySimpleSingleton {

    private static LazySimpleSingleton lazySingleton = null;

    private LazySimpleSingleton() {
    }

    public static LazySimpleSingleton getInstance() {

        if (lazySingleton == null) {
            lazySingleton = new LazySimpleSingleton();
        }
        return lazySingleton;
    }
}

　我們用執行緒測一下在多執行緒場景下會不會出現問題

先建立一個執行緒類

public class ExectorTread implements Runnable {


    @Override
    public void run() {
        LazySimpleSingleton instance = LazySimpleSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + instance);
    }
}

測試

public class LazySimpleSingletonTest {

    public static void main(String[] args) {

        Thread t1 = new Thread(new ExectorTread());
        Thread t2 = new Thread(new ExectorTread());

        t1.start();
        t2.start();

        System.out.println("Exector End");
    }
}

　　執行結果

結果發現建立的物件不一樣

如果在方法上加入鎖會解決問題

public class LazySimpleSingleton {

    private static LazySimpleSingleton lazySingleton = null;

    private LazySimpleSingleton() {
    }

    public synchronized static LazySimpleSingleton getInstance() {

        if (lazySingleton == null) {
            lazySingleton = new LazySimpleSingleton();
        }
        return lazySingleton;
    }
}

　　雖然jdk1.6之後對synchronized效能優化了不少，但是還是存在一定的效能問題，這種寫法會造成整個類被鎖住，大大降低了效能

於是我們有了新的寫法

二、懶漢式第二種：
public class LazyDoubleCheckSingleton {

    private volatile static LazyDoubleCheckSingleton lazySingleton = null;

    private LazyDoubleCheckSingleton() {
    }
    //    適中方案
    //    雙重檢查鎖
    public static LazyDoubleCheckSingleton getInstance() {

        if (lazySingleton == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                if (lazySingleton == null) {
                    lazySingleton = new LazyDoubleCheckSingleton();
                }
            }
        }
        return lazySingleton;
    }
}

知識補充：

　　1、執行緒安全性開發遵循三個原則：

  • 原子性：即一個操作或者多個操作要麼全部執行,要麼都不執行
  • 可見性：多個執行緒訪問同一變數時,一個執行緒修改了這個變數的值,其他執行緒能夠立即看到修改的值
  • 有序性：程式執行的順序按照程式碼的先後順序執行

　　通過對這段程式碼執行緒的debug發現，這裡雙重檢查體現了可見性

　　2、JVM：CPU在執行的時候會轉換成JVM指令

　lazySingleton = new LazySimpleSingleton(); 這行程式碼實際進行了如下操作

  • 　　　　第一步、分配記憶體給物件
  • 　　　　第二步、初始化物件
  • 　　　　第三步、將初始化物件和記憶體地址關聯（賦值）
  • 　　　　第四步、使用者初次訪問

在多執行緒環境中，第二步和第三步可能會發生顛倒，這就需要指令重排序，於是我們在變數宣告上加上volatile關鍵字就很好的解決了問題

volatile相關部落格

三、懶漢式第三種

通過內部類的方式實現

public class LazyInnerClassSingleton {

    private LazyInnerClassSingleton() {
    }

    public static final LazyInnerClassSingleton getInstance() {
        return LazyHolder.LAZY;
    }

    private static class LazyHolder {
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

　　效能上最優的一種寫法，全程沒有用到synchronized，

　　通過懶載入餓漢式寫法達到了懶漢式的目的，LazyHolder裡面的邏輯要等到外面呼叫才執行，巧妙地運用了內部類的特性

　　有人會問這個不用考慮執行緒安全嗎？其實這是利用了JVM底層的執行邏輯，完美的避開了執行緒安全性的問題

但是我們會考慮另一個問題，該類構造器雖然私有了，但是還是會被反射攻擊，難逃反射法眼

我們來測試一下

public class LazyInnerClassSingletonTest {

    public static void main(String[] args) {

        try {
//          呼叫者裝B，不走尋常路，顯然搞壞了單例
            Class<LazyInnerClassSingleton> clazz = LazyInnerClassSingleton.class;
            Constructor<LazyInnerClassSingleton> constructor = clazz.getDeclaredConstructor();
            constructor.setAccessible(true);//強吻（問）
            LazyInnerClassSingleton instance = constructor.newInstance();
            System.out.println(instance);
//          正常呼叫
            LazyInnerClassSingleton instance2 = LazyInnerClassSingleton.getInstance();
            System.out.println(instance2);
            System.out.println(instance == instance2);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

　　執行結果

針對反射問題我們有了以下解決辦法

public class LazyInnerClassSingleton {

    private LazyInnerClassSingleton() {
        if (LazyHolder.LAZY != null){
            throw new RuntimeException("不允許構建多個例項");
        }
    }

    public static final LazyInnerClassSingleton getInstance() {
        return LazyHolder.LAZY;
    }

    private static class LazyHolder {
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

　　在私有構造方法上加上判斷，如果已經物件被初始化就丟擲異常

好的，被反射破壞的問題解決了，還會想到另一個問題，如果被反序列化物件還是單例嗎？

　　知識點補充：反序列化是將已經持久的的位元組碼內容，轉換為IO流，在轉換過程中重新建立物件new。

我們拿餓漢式單例測試一下

單例類：

public class SeriableSingleton implements Serializable {

    private static final SeriableSingleton singleton = new SeriableSingleton();

    private SeriableSingleton() {
    }

    public static SeriableSingleton getInstance() {
        return singleton;
    }
}

測試類：

public class SeriableSingletonTest {

    public static void main(String[] args) {

        FileOutputStream fso = null;
        SeriableSingleton s1 = null;
        SeriableSingleton s2 = SeriableSingleton.getInstance();

        try {
            fso = new FileOutputStream("SeriableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fso);
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (SeriableSingleton) ois.readObject();
            ois.close();

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

　　執行結果

顯然反序列化破壞了單例

現在我們通過原始碼尋找答案

進入readObject()方法

方法通過呼叫readObject0(false)返回結果，再次進入readObject0()方法

找到object型別，呼叫了checkResolve(readOrdinaryObject(unshared)),進入readOrdinaryObject方法

在這裡我們找到了例項化物件的語句

obj = desc.isInstantiable() ? desc.newInstance() : null;

意思是如果這個物件能被初始化就例項化物件，否則等於null

在這裡打個斷點除錯一下，確實例項化了物件，存在私有構造方法也會例項化物件

接著往下看

如果desc.hasReadResolveMethod()返回true，就呼叫Object rep = desc.invokeReadResolve(obj);返回obj

進入hasReadResolveMethod

原始碼分析過後發現這個hasReadResolveMethod（）方法是用來判斷readResolve方法是否存在，如果存在返回true，不存在返回false

再看invokeReadResolve()方法

返回了readResolve這個方法的返回值，

所以經過這個判斷會重新載入物件並返回

接下來我們得出結論，程式碼增加重寫方法readResolve

public class SeriableSingleton implements Serializable {

    private static final SeriableSingleton singleton = new SeriableSingleton();

    private SeriableSingleton() {
    }

    public static SeriableSingleton getInstance() {
        return singleton;
    }

    protected Object readResolve() {
        return singleton;
    }
}

　　再次執行解決了序列化的問題

但是值得我們注意的是，重寫readResolve方法只不過是覆蓋了反序列化出來的物件，物件還是建立了2次，

由於發生再JVM層面，相對來說比較安全，在之前沒有被引用的物件會被GC回收（JVM知識點）

註冊式單例

一、第一種寫法

使用列舉類實現單例模式，也是《Effictive Java》這本書推薦的寫法

public enum EnumSingleton {

    INSTANCE;

    private Object data;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

1、首先判斷執行緒安全性

　　通過反編譯工具JAD得到列舉類的原始碼，附：JAD下載地址

public final class EnumSingleton extends Enum
{

    public static EnumSingleton[] values()
    {
        return (EnumSingleton[])$VALUES.clone();
    }

    public static EnumSingleton valueOf(String name)
    {
        return (EnumSingleton)Enum.valueOf(com/zc/singleton/register/EnumSingleton, name);
    }

    private EnumSingleton(String s, int i)
    {
        super(s, i);
    }

    public Object getData()
    {
        return data;
    }

    public void setData(Object data)
    {
        this.data = data;
    }

    public static EnumSingleton getInstance()
    {
        return INSTANCE;
    }

    public static final EnumSingleton INSTANCE;
    private Object data;
    private static final EnumSingleton $VALUES[];

    static 
    {
        INSTANCE = new EnumSingleton("INSTANCE", 0);
        $VALUES = (new EnumSingleton[] {
            INSTANCE
        });
    }
}

通過程式碼發現，靜態程式碼塊例項化了單例類，屬於餓漢式單列，不存線上程安全性問題，這個例項化過程發生在JVM層面，所以可以認為懶載入

2、測試序列化

public class EnumSingletonTest {


    public static void main(String[] args) {

        FileOutputStream fso = null;
        EnumSingleton s1 = null;
        EnumSingleton s2 = EnumSingleton.getInstance();
        s2.setData(new Object());

        try {
            fso = new FileOutputStream("EnumSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fso);
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("EnumSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (EnumSingleton) ois.readObject();
            ois.close();

            System.out.println(s1.getData());
            System.out.println(s2.getData());
            System.out.println(s1.getData() == s2.getData());


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

執行結果 ：

列舉類是怎樣避免不被序列化破壞的呢？我們來檢視原始碼

首先進入列舉型別case

進入readEnum方法

通過列舉類物件根據註冊的類名獲取例項然後返回，所以不會建立新的物件

3、測試反射

//        反射
        try {
            Class<EnumSingleton> clazz = EnumSingleton.class;
            Constructor<EnumSingleton> constructor = clazz.getDeclaredConstructor();
            constructor.setAccessible(true);
            constructor.newInstance();

        }catch (Exception e){
            e.printStackTrace();
        }

執行結果 ：

報錯：沒有找到這樣的構造方法

反編譯獲取的類有這樣的一個構造方法

private EnumSingleton(String s, int i)
    {
        super(s, i);
    }

我們用這個構造再例項化一次看看

測試：

//        反射
        try {
            Class<EnumSingleton> clazz = EnumSingleton.class;
            Constructor<EnumSingleton> constructor = clazz.getDeclaredConstructor(String.class,int.class);
            constructor.setAccessible(true);
            EnumSingleton instance = constructor.newInstance("zhou", 666);
            System.out.println(instance);

        }catch (Exception e){
            e.printStackTrace();
        }

執行結果：

報錯：不能通過反射建立這個列舉物件

檢視原始碼：

得知如果該類的型別為列舉類，就丟擲異常

總結：從JDK層面就為列舉類不被例項化和反射保駕護航

二、第二種寫法

容器式單例，Spring容器中單例的寫法

public class ContainerSingleton {

    private ContainerSingleton() {}

    private static Map<String, Object> ioc = new ConcurrentHashMap<String, Object>();

    public static Object getBean(String className){

        synchronized (ioc){

            if (!ioc.containsKey(className)){
                Object obj = null;
                try {
                    obj = Class.forName(className).newInstance();
                    ioc.put(className,obj);
                }catch (Exception e){
                    e.printStackTrace();
                }
                return obj;
            }
            return ioc.get(className);
        }

    }
}

優點：物件方便管理，其實也是屬於懶載入

ThreadLocal

使用ThreadLocal實現單例模式

//偽執行緒安全
public class ThreadLocalSingleton {

    private ThreadLocalSingleton(){}

    private static final ThreadLocal<ThreadLocalSingleton> threadLocalSingleton = new ThreadLocal<ThreadLocalSingleton>(){
        @Override
        protected ThreadLocalSingleton initialValue() {
            return new ThreadLocalSingleton();
        }
    };

    public static ThreadLocalSingleton getInstance(){
        return threadLocalSingleton.get();
    }
}

測試多執行緒

public class ExectorTread implements Runnable {


    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName() + ":" + ThreadLocalSingleton.getInstance());
        System.out.println(Thread.currentThread().getName() + ":" + ThreadLocalSingleton.getInstance());
        System.out.println(Thread.currentThread().getName() + ":" + ThreadLocalSingleton.getInstance());
        System.out.println(Thread.currentThread().getName() + ":" + ThreadLocalSingleton.getInstance());
        System.out.println(Thread.currentThread().getName() + ":" + ThreadLocalSingleton.getInstance());
    }
}
public class ThreadLocalSingletonTest {

    public static void main(String[] args) {

        System.out.println(Thread.currentThread().getName() +  ":" +ThreadLocalSingleton.getInstance());
        System.out.println(Thread.currentThread().getName() +  ":" +ThreadLocalSingleton.getInstance());
        System.out.println(Thread.currentThread().getName() +  ":" +ThreadLocalSingleton.getInstance());
        System.out.println(Thread.currentThread().getName() +  ":" +ThreadLocalSingleton.getInstance());
        System.out.println(Thread.currentThread().getName() +  ":" +ThreadLocalSingleton.getInstance());

        Thread t1 = new Thread(new ExectorTread());
        t1.start();
        Thread t2 = new Thread(new ExectorTread());
        t2.start();
    }
}

列印結果

結論：該單例在單個執行緒中可以保持單例，但是每個其他執行緒互相都不一樣

　　　　原理：每次獲取例項會從ThreadLocalMap中取值，而每個單例的key就是執行緒名

屬於註冊式單例（容器形式）

應用場景：Spring的orm框架中

以上對單例模式的介紹到此結束，歡迎批評指正。附：原始碼地址

相關推薦

設計模式之單例模式（Singleton Pattern）深入淺出

單例模式介紹：單例模式是指確保一個類在任何情況下都絕對只有一個例項，並且提供一個全域性的訪問點。隱藏其所有構造方法，屬於創新型模式。

23種設計模式之單例模式詳解（最詳細）

單例模式 　　在有些系統中，為了節省記憶體資源、保證資料內容的一致性，對某些類要求只能建立一個例項，這就是所謂的單例模式。

設計模式之單例模式(Singleton)解析及應用

技術標籤：設計模式c++設計模式單例模式 單例模式是設計模式中比較常見的一種，屬於建立型模式，本文記錄一下單例模式用法及一些問題點。

c#設計模式之單例模式的實現方式

場景描述 單例模式對於我們來說一點也不模式，是一個常見的名稱，單例模式在程式中的實際效果就是：確保一個程式中只有一個例項，並提供一個全域性訪問點，節省系統資源

C#設計模式之單例模式

單例模式是最簡單的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。這種模式涉及到一個單一的類，該類負責建立自己的物件，同時確保只有單個物件被建立。這個類提供了一種訪問其

設計模式之單例模式

單例模式保證一個類僅有一個例項，並提供一個訪問它的全域性訪問點。這是個非常有意思的設計模式，使用和理解起來都比較簡單，但是單例的寫法有好多種，下面挑重點的介紹。

Java設計模式之單例模式、工廠模式、PO模式【多測師_王sir】

一）、工廠模式 工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種型別的

設計模式之單例模式的多種使用方式

設計模式之單例模式 具體使用案例如下： using System; using System.Collections.Concurrent;

設計模式之單例模式詳解

單例模式 認識單例模式 什麼是單例模式 單例設計模式，就是採取一定的方法保證在整個的軟體系統中，對某個類只能存在一個物件例項，並且該類只提供一個取得其物件例項的方法（靜態方法）。

javascript中的設計模式之單例模式

一、定義 保證一個類僅有一個例項，並提供一個訪問它的全域性訪問點 二、舉例

設計模式之單例模式(控制檯方法)

介紹 單例模式是軟體工程中最著名的模式之一。從本質上講，單例是一個只允許建立自身的單個例項的類，並且通常可以簡單地訪問該例項。最常見的是，單例不允許在建立例項時指定任何引數——否則對例項的第二

java設計模式之 -- 單例模式

單例模式 單例模式是GoF設計模式其中的一種並且屬於創造的設計模式目錄。 單例模式限制類的例項和確保java類在java虛擬機器中只有一個例項的存在。

Java設計模式之單例模式_懶漢式

單例模式 初識： 單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。

PHP設計模式之單例模式

前言 PHP設計模式多達23種，但常用的就幾種，今天就介紹一下其中常用的。 常用的設計模式有三種：單例模式、工廠模式（普通工廠、抽象工廠）

解析C#設計模式之單例模式

單例模式（Singleton)，故名思議就是說在整個應用程式中，某一物件的例項只應該存在一個。比如，一個類載入資料庫中的資料到記憶體中以提供只讀資料，這就很適合使用單例模式，因為沒有必要在記憶體中載入多份相同的

3 設計模式之單例模式

技術標籤：java設計模式23種 單例模式 單例模式，該模式也是一種物件的創新方式。當全域性物件只需要一個例項時，就可以使用單例模式。

C++--設計模式之單例模式

技術標籤：C++c++設計模式 目錄 1.單例模式介紹2.懶漢模式3.餓漢模式4.多執行緒+單例模式5.單例模式的適用場景6.靜態成員函式及變數擴充套件說明

面向物件設計模式之單例模式

單例物件的類必須保證只有一個例項存在。 餓漢模式 /** * 餓漢模式 */ public class HungrySingleton {

程式碼操作中經常使用到設計模式之單例模式

前言： 應一位小朋友之邀繼續分享一下設計模式，關於設計模式的基本介紹在上一篇文章已經有所描述，這篇就不多做贅述。今天給大家介紹一下設計模式的裡面的入門篇——單例模式。

01 設計模式之單例模式

1 場景分析 平常開發中，呼叫其他系統的介面是很常見的，呼叫一般需要用到一些配置資訊，而這些配置資訊一般在配置檔案中，程式啟動時讀取到記憶體中使用。