簡介

單例模式（Singleton Pattern）屬于創建型設計模式，這種模式只創建一個單一的類，保證一個類只有一個實體，并提供一個訪問該實體的全域節點，

當您想控制實體數目，節省系統資源，并不想混用的時候，可以使用單例模式，單例有很多種實作方式，主要分為懶漢和餓漢模式，同時要通過加鎖來避免執行緒安全，不同語言的單例實作略有差異，可以通過查看不同版本的原始碼來深入理解其中的差異，

作用

避免全域使用的類頻繁地創建與銷毀，
保證一個類僅有一個實體，并提供一個訪問它的全域訪問點，

實作步驟

創建單例類，注意執行緒安全
回傳全域唯一實體

UML

Java代碼

單例實作，不同語言有很大不同，跟語言特性有關，請查看其他原始碼進行比較，

餓漢式（執行緒安全）

// SingletonEager.java 當類被加載的時候會初始化，靜態變數被創建并分配記憶體空間 
public class SingletonEager {
  private String name = "SingletonEager";
  // 類加載時就初始化，浪費記憶體
  private static final SingletonEager instance = new SingletonEager();

  // 建構式是private，不允許實體化
  private SingletonEager() {

  }
  public static SingletonEager getInstance() {
    return instance;
  }

  public void run() {
    System.out.println("SingletonEager::run() " + this.name);
  }
}

飽漢式

// SingletonLazy.java 懶漢式也叫飽漢式，增加synchronized來保證執行緒安全
public class SingletonLazy {

  private static SingletonLazy instance;
  private String name;

  private SingletonLazy() {

  }

  // 類初始化時，靜態變數static的instance未被創建并分配記憶體空間
  // 當getInstance方法第一次被呼叫時，再初始化instance變數，并分配記憶體
  // 相當于延遲到呼叫時再實體化，加synchronized以便執行緒安全，不加則存在并發時多個實體的情形
  public static synchronized SingletonLazy getInstance(String name) {
    if (instance == null) {
      instance = new SingletonLazy();
      instance.name = name;
    }
    return instance;
  }

  public void run() {
    System.out.println("SingletonLazy::run() " + this.name);
  }
}

靜態內部類

// SingletonInner.java 靜態內部類方式，既實作延遲加載，也保障執行緒安全，
public class SingletonInner {

  private String name;

  private SingletonInner() {

  }

  // 靜態內部類利用了類加載初始化機制，外部類加載時，并不會加載內部類，也不會執行
  // 虛擬機會保證方法在多執行緒環境下使用加鎖同步，只會執行一次，因此執行緒安全
  private static class Inner {
    private static final SingletonInner instance = new SingletonInner();
  }

  // 當執行getInstance()方法時，虛擬機才會加載靜態內部類
  public static SingletonInner getInstance(String name) {
    if (Inner.instance.name == null) {
      Inner.instance.name = name;
    }
    return Inner.instance;
  }

  public void run() {
    System.out.println("SingletonInner::run() " + this.name);
  }
}

雙重檢驗懶漢

// SingletonDoubleCheck.java 雙重檢驗懶漢單例，單例模式最優方案，執行緒安全并且效率高 
public class SingletonDoubleCheck {

  // 定義一個靜態私有變數(不初始化，不使用final關鍵字）
  // 可以使用volatile保證多執行緒訪問時變數的可見性
  // 這樣避免了初始化時其他變數屬性還沒賦值完時，被另外執行緒呼叫
  private static volatile SingletonDoubleCheck instance;
  private String name;
  private SingletonDoubleCheck() {

  }

  // 延遲到呼叫時實體化
  public static SingletonDoubleCheck getInstance(String name) {
    if (instance == null) {
      // 在實體化時再synchronized
      synchronized (SingletonDoubleCheck.class) {
        if (instance == null) {
          instance = new SingletonDoubleCheck();
          instance.name = name;
        }
      }
    }
    return instance;
  }

  public void run() {
    System.out.println("SingletonDoubleCheck::run() " + this.name);
  }
}

測驗呼叫

    /**
     * 單例模式就是一個類只創建一個實體，以便節省開銷和保證統一
     * 對于多執行緒語言需要注意執行緒安全和性能之間取得一個平衡
     */
    SingletonEager singletonEager1 = SingletonEager.getInstance();
    SingletonEager singletonEager2 = SingletonEager.getInstance();
    singletonEager1.run();
    singletonEager2.run();
    // 兩個實體相等
    System.out.println("singletonEager1 == singletonEager2 ? " + String.valueOf(singletonEager1 == singletonEager2));

    /*********************** 分割線 ******************************************/

    SingletonLazy singletonLazy1 = SingletonLazy.getInstance("singletonLazy1");
    SingletonLazy singletonLazy2 = SingletonLazy.getInstance("singletonLazy2");
    singletonLazy1.run();
    singletonLazy2.run();

    /*********************** 分割線 ******************************************/

    SingletonDoubleCheck singletonDoubleCheck1 = SingletonDoubleCheck.getInstance("singletonDoubleCheck1");
    SingletonDoubleCheck singletonDoubleCheck2 = SingletonDoubleCheck.getInstance("singletonDoubleCheck2");
    singletonDoubleCheck1.run();
    singletonDoubleCheck2.run();

    /*********************** 分割線 ******************************************/

    SingletonInner singletonInner1 = SingletonInner.getInstance("singletonInner1");
    SingletonInner singletonInner2 = SingletonInner.getInstance("singletonInner2");
    singletonInner1.run();
    singletonInner2.run();

Go代碼

// DoubleCheckSingleton.go
import (
  "fmt"
  "sync"
)

// 安全懶漢模式的升級版，通過sync的Mutex實作雙重檢驗
type DoubleCheckSingleton struct {
  name string
}

func (s *DoubleCheckSingleton) Run() {
  fmt.Println("DoubleCheckSingleton::run()", s.name)
}

// 定義私有變數，用來保存實體
var doubleCheckSingletonInstance *DoubleCheckSingleton
var lock = &sync.Mutex{}

// 是懶漢模式安升級版，雙重檢查來來支持延遲實體化單例物件
func GetDoubleCheckSingletonInstance(name string) *DoubleCheckSingleton {
  // 未實體化才進行加鎖
  if doubleCheckSingletonInstance == nil {
    lock.Lock()
    defer lock.Unlock()
    // 為了保險，鎖住之后再次檢查是否已實體化
    if doubleCheckSingletonInstance == nil {
      doubleCheckSingletonInstance = &DoubleCheckSingleton{}
      doubleCheckSingletonInstance.name = name
    }
  }

  return doubleCheckSingletonInstance
}

JS版本

// LazySingleton.js
export class LazySingleton {
  static instance
  constructor(alias) {
    this.alias = alias
  }

  // 懶漢模式，延遲實體化，請求實體時判斷，如果已經實體化過就直接回傳
  // js是單執行緒語言，無需考慮多執行緒問題
  static getInstance(alias) {
    if (this.instance === undefined) {
      this.instance = new LazySingleton(alias)
    }
    return this.instance
  }

  run() {
    console.log('LazySingleton::run()', this.alias)
  }
}

Python語言

# SingletonSafe.py
from threading import Lock, Thread


# 加鎖的基于元類的單例模式，基于元類type創建的加強版
class SingletonMeta(type):
    # 執行緒安全單例模式，適用python3
    _instances = {}

    _lock: Lock = Lock()

    def __call__(cls, *args, **kwargs):
        with cls._lock:
            if cls not in cls._instances:
                instance = super().__call__(*args, **kwargs)
                cls._instances[cls] = instance
        return cls._instances[cls]

# 繼承SingletonMeta就是單例
class SingletonSafe(metaclass=SingletonMeta):
    name: str = None

    def __init__(self, name: str) -> None:
        self.name = name

    def run(self):
        print('SingletonSafe::run()', self.name)

C語言

// lazy_singleton_safe.c
#include "func.h"
#include <pthread.h>

// 靜態指標，未被創建并分配記憶體空間，指向唯一實體
static LazySingletonSafe *lazy_singleton_safe_instance = NULL;

void lazy_singleton_safe_run(LazySingletonSafe *singleton)
{
  printf("\r\n LazySingletonSafe::run() [name=%s value=https://www.cnblogs.com/letjs/archive/2023/04/27/%d]", singleton->name, singleton->value);
}

// 內部私有實體化函式，不公開
static LazySingletonSafe *new_lazy_singleton_safe(char *name)
{
  LazySingletonSafe *singleton = (LazySingletonSafe *)malloc(sizeof(LazySingletonSafe));
  strcpy(singleton->name, name);
  singleton->run = &lazy_singleton_safe_run;
  return singleton;
}

// 宣告鎖
pthread_mutex_t singleton_lock;

// 非執行緒安全懶漢模式，延遲初始化，多個執行緒同時呼叫函式時， 可能會被初始化多次，存在執行緒不安全問題
LazySingletonSafe *get_lazy_singleton_safe_instance(char *name)
{
  printf("\r\n get_lazy_singleton_safe_instance() [name=%s]", name);
  if (pthread_mutex_init(&singleton_lock, NULL) != 0)
  {
    perror("error init mutext:");
  }

  // 通過加鎖來防止執行緒并發導致的不安全
  if (lazy_singleton_safe_instance == NULL)
  {
    printf("\r\n new instance [name=%s]", name);
    pthread_mutex_lock(&singleton_lock);
    lazy_singleton_safe_instance = new_lazy_singleton_safe(name);
    pthread_mutex_unlock(&singleton_lock);
  }
  return lazy_singleton_safe_instance;
}

【單例設計模式原理詳解】Java/JS/Go/Python/TS不同語言實作

簡介

作用