簡介單例模式（Singleton Pattern）屬於創建型設計模式，這種模式只創建一個單一的類，保證一個類只有一個實例，並提供一個訪問該實例的全局節點。當您想控制實例數目，節省系統資源，並不想混用的時候，可以使用單例模式。單例有很多種實現方式，主要分為懶漢和餓漢模式，同時要通過加鎖來避免線程安 ...

簡介

單例模式（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=%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不同語言實現

簡介

作用