初識設計模式 – 單例模式

簡介

一個類只允許創建一個對象（或實例），那麼這個類就是一個單例類，這種設計模式稱作單例設計模式（Singleton Design Pattern），簡稱單例模式。

單例模式保證系統內存中只存在一個對象，非常節省系統資源，對於一些需要頻繁銷毀的對象，使用單例模式可以提高系統性能。

一個普通單例模式的實現方式主要是以下三個步驟：

  1. 將單例類的構造方法定義為私有方法，禁止外部直接調用構造方法來實例化單例類的對象；
  2. 在類的內部創建並保存類的唯一實例，並設置成私有變量，禁止外部直接調用這個實例變量；
  3. 創建一個公開的靜態方法，對外暴露類的唯一實例。

具體實現

餓漢式

餓漢式的實現方式就是，在類裝載的期間，將類的實例初始化好，然後通過靜態方法拿到實例化的對象。

對應的 Java 代碼片段如下：

public class Singleton {
    // 靜態實例化
    private static final Singleton instance = new Singleton();

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

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

除了通過使用靜態常量初始化實例的方式以外，還可以通過靜態代碼塊的方式實現餓漢式單例模式。

對應的 Java 代碼片段如下：

public class Singleton {
    // 靜態變量
    private static final Singleton instance;

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

    // 靜態代碼塊
    static {
        instance = new Singleton();
    }

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

餓漢式的優點是，在類裝載的時候就完成了實例化，避免了線程同步問題。

但是，這樣的實現方式不支持延遲加載實例，如果從始至終未使用過這個實例，就會造成內存浪費。

並且，餓漢式在一些場景中無法使用：比如單例類實例的創建是依賴參數或者配置文件的，在通過 getInstance() 方法獲取實例對象之前需要調用某個方法設置參數給對象實例，則這種方式將無法使用。

懶漢式

懶漢式相對於餓漢式的優勢是支持延遲加載，可以在需要使用實例的時候才進行初始化。

對應的 Java 代碼片段如下：

public class Singleton {
    // 靜態變量
    private static Singleton instance;

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

    public static Singleton getInstance() {
        if (instance == null) {
            // 實例不存在時初始化
            instance = new Singleton();
        }
        return instance;
    }
}

上述的實現方式是線程不安全的，如果有兩個線程同時進入到 getInstance() 方法，並且正好都通過了判斷語句，這時便會產生多個實例。通常不建議在生產環境中使用線程不安全的懶漢式創建單例類。

為了做到線程安全，可以給 getInstance() 方法加一把鎖。

對應的 Java 代碼片段如下：

public class Singleton {
    // 靜態變量
    private static Singleton instance;

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

    // 使用 synchronized 對方法進行加鎖
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            // 實例不存在時初始化
            instance = new Singleton();
        }
        return instance;
    }
}

上述在 getInstance() 方法加鎖的方式解決了線程不安全的問題，但是，由於加鎖的粒度較大，實際的效率非常低。

如果這個單例類偶爾會被使用到，那這種實現方式還可以接受。但是，如果頻繁地用到，那頻繁加鎖、釋放鎖則會出現並發度低的問題，造成性能瓶頸。

因此，也不建議在生產環境中使用線程安全的懶漢式創建單例類。

雙重檢測

餓漢式和懶漢式的實現方式都有一定的限制，而雙重檢測的實現方式是一種既支持延遲加載、又支持高並發的單例實現方式。

對應的 Java 代碼片段如下：

public class Singleton {
    // 靜態變量
    private static Singleton instance;

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

    public static Singleton getInstance() {
        // 一次檢測
        if (instance == null) {
            synchronized (Singleton.class) {
                // 二次檢測
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

當有兩個線程同時進入到 getInstance() 方法時，雖然會出現都通過第一次檢查的判斷語句，但是只會有一個線程獲得鎖並實例化對象，即使後續再有線程進入到同步代碼塊中，也會被第二次檢查的判斷語句擋在外面。

雙重檢測方式在多線程開發中常使用到，其優點是線程安全、支持延遲加載、效率較高。在實際開發中比較推薦使用這種方式實現單例模式。

靜態內部類

靜態內部類是一種比雙重檢測更加簡單的實現方式。它有點類似餓漢式，但又能做到延遲加載。

對應的 Java 代碼片段如下：

public class Singleton {
    // 靜態內部類
    private static class SingletonHolder {
        // 初始化實例
        private static final Singleton instance = new Singleton();
    }

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

    public static Singleton getInstance() {
        // 返回內部類的靜態實例
        return SingletonHolder.instance;
    }
}

這種方式採用類裝載機制來保證初始化實例時只有一個線程。

靜態內部類方式在單例類被加載的時候並不會立即實例化，而是在調用 getInstance() 方法的時候，才會裝載 SingletonHolder 類，從而實現單例類的實例化。

類的靜態屬性只會在第一次加載類的時候初始化，實例的唯一性、創建過程的線程安全性，都由 JVM 來保證。

所以，這種實現方法既保證了線程安全，又能做到延遲加載，效率也比較高，也是一種推薦使用的實現方式。

枚舉

基於枚舉類型的單例實現，是最簡單的實現方式。

對應的 Java 代碼片段如下：

public enum Singleton {
    // 實例屬性
    INSTANCE;

    public void doSomething() {
        // 通過以下方式調用此方法
        // Singleton.INSTANCE.doSomething();
    }
}

這種方式是通過 Java 枚舉類型本身的特性，保證了實例創建的線程安全性和實例的唯一性，還能防止反序列化重新創建新的對象。

這種方式是Effective Java中文版（第3版）作者提倡的方式，推薦在生產環境中使用。

深度理解

單例模式唯一性的範圍

單例類只允許創建唯一對象（或實例），這裡對象的唯一性範圍指的是進程內只允許創建一個對象。

進程之間是不共享地址空間的，如果在一個進程中創建另一個進程，操作系統會給新進程分配新的地址空間，並且將老進程地址空間的所有內容重新拷貝一份到新進程的地址空間中，這些內容包括代碼、數據。

所以，單例類在老進程中存在且只能存在一個對象，在新進程中也會存在且只能存在一個對象。而且，這兩個對象不是同一個對象。

實現線程唯一的單例

「進程唯一」指的是進程內唯一，進程間不唯一。類比得知，「線程唯一」指的是線程內唯一，線程間不唯一。

其實，「進程唯一」的單例在同一個進程中的線程間唯一，若要做到「線程唯一」，主要是做到線程間保持不唯一。

實現線程唯一單例的代碼很簡單，可以通過一個鍵值對做關聯存儲，其中 key 是線程 ID，value 是對象。

對應的 Java 代碼片段如下：

import java.util.concurrent.ConcurrentHashMap;

public class Singleton {
    // 保證線程唯一的鍵值對
    private static final ConcurrentHashMap<Long, Singleton> instanceMap = new ConcurrentHashMap<>();

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

    public static Singleton getInstance() {
        Long currentThreadId = Thread.currentThread().getId();
        instanceMap.putIfAbsent(currentThreadId, new Singleton());
        return instanceMap.get(currentThreadId);
    }
}

實現集群唯一的單例

這裡的集群表示進程集群，類比可知，「集群唯一」相當於進程間也唯一，即在不同的進程間共享同一個對象，不創建同一個類的多個對象。

實現集群唯一單例需要依賴到外部共享存儲區：將單例對象序列化並存儲到外部共享存儲區，在使用這個單例對象的時候，需要先從外部共享存儲區中將它讀取到內存，並反序列化成對象，然後再使用，使用完成之後還需要再存儲回外部共享存儲區。

為了保證任何時刻在集群中都只有一份對象存在，一個進程在獲取到對象之後，需要對對象加鎖，避免其他進程再將其獲取。

在進程使用完這個對象之後，還需要顯式地將對象從內存中刪除，並且釋放對象的鎖。

實現一個多例模式

「多例」指的是，一個類可以創建多個對象，但是個數是有限制的，同無限個有一些區別。

多例模式的實現也比較簡單，通過一個鍵值對存儲索引和對象之間的對應關係，並且需要控制對象的個數。

對應的 Java 代碼片段如下：

import java.util.Map;
import java.util.HashMap;
import java.util.Random;

public class Multipleton {
    // 限制實例數量
    private static final int COUNT = 3;

    // 存儲對應關係的鍵值對
    private static final Map<Integer, Multipleton> instanceMap = new HashMap<>();

    // 餓漢式實現
    static {
        instanceMap.put(0, new Multipleton());
        instanceMap.put(1, new Multipleton());
        instanceMap.put(2, new Multipleton());
    }

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

    // 公有靜態方法，返回對應索引的實例對象
    public static Multipleton getInstance(Integer index) {
        return instanceMap.get(index);
    }

    // 公有靜態方法，返回隨機索引的實例對象
    public static Multipleton getRandomInstance() {
        Random random = new Random();
        Integer index = random.nextInt(COUNT);
        return instanceMap.get(index);
    }
}

總結

優點

單例模式的主要優點如下：

  • 提供了對唯一實例的受控訪問，封裝性非常好
  • 系統內存中只存在一個對象，可以節省系統資源
  • 基於單例模式，可擴展實現多例類，既節省系統資源，又解決了由於單例模式共享過多有損性能的問題

缺點

單例模式的主要缺點如下：

  • 單例模式對面向對象特性的支持不友好，違背了基於接口而非實現的設計原則
  • 單例模式對代碼的擴展性不友好，如要擴展則會導致改動較大
  • 常規的單例模式不支持有參數的構造函數，只能通過其他方式改動單例類中的成員變量
  • 對於有 GC 的編程語言，如果長時間不使用實例化的對象，則單例對象有可能會被銷毀

適用場景

單例模式的適用場景如下：

  • 單例模式主要針對需要頻繁地創建和銷毀的對象，可以理解成創建對象時耗時過多或耗費資源較大但又經常用到的對象。如工具類對象、頻繁訪問的數據庫或文件對象
  • 從業務概念上看，有些數據在系統中只應該保存一份，就比較適合設計成單例類。比如，系統的配置信息類
  • 可以使用單例解決資源訪問衝突的問題，單例模式可以只提供一個公共訪問點

源碼

在 JDK 中，java.lang.Runtime 是經典的單例模式，其用於與 Java 運行時環境進行交互。

Runtime 類是一個典型的餓漢式單例模式實現，如下是其的一些實現邏輯：

public class Runtime {
    // 靜態實例化
    private static final Runtime currentRuntime = new Runtime();

    private static Version version;

    // 靜態方法獲取靜態實例
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    // 構造器私有化
    private Runtime() {}
Tags:

VirMach 便宜 VPS

QNews

QNews