// SingletonEager.java 當(dāng)類被加載的時(shí)候會初始化，靜態(tài)變量被創(chuàng)建并分配內(nèi)存空間 
public class SingletonEager {
  private String name = "SingletonEager";
  // 類加載時(shí)就初始化，浪費(fèi)內(nèi)存
  private static final SingletonEager instance = new SingletonEager();

  // 構(gòu)造函數(shù)是private，不允許實(shí)例化
  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() {

  }

  // 類初始化時(shí)，靜態(tài)變量static的instance未被創(chuàng)建并分配內(nèi)存空間
  // 當(dāng)getInstance方法第一次被調(diào)用時(shí)，再初始化instance變量，并分配內(nèi)存
  // 相當(dāng)于延遲到調(diào)用時(shí)再實(shí)例化，加synchronized以便線程安全，不加則存在并發(fā)時(shí)多個(gè)實(shí)例的情形
  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 靜態(tài)內(nèi)部類方式，既實(shí)現(xiàn)延遲加載，也保障線程安全。
public class SingletonInner {

  private String name;

  private SingletonInner() {

  }

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

  // 當(dāng)執(zhí)行g(shù)etInstance()方法時(shí)，虛擬機(jī)才會加載靜態(tài)內(nèi)部類
  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 雙重檢驗(yàn)懶漢單例，單例模式最優(yōu)方案，線程安全并且效率高 
public class SingletonDoubleCheck {

  // 定義一個(gè)靜態(tài)私有變量(不初始化，不使用final關(guān)鍵字）
  // 可以使用volatile保證多線程訪問時(shí)變量的可見性
  // 這樣避免了初始化時(shí)其他變量屬性還沒賦值完時(shí)，被另外線程調(diào)用
  private static volatile SingletonDoubleCheck instance;
  private String name;
  private SingletonDoubleCheck() {

  }

  // 延遲到調(diào)用時(shí)實(shí)例化
  public static SingletonDoubleCheck getInstance(String name) {
    if (instance == null) {
      // 在實(shí)例化時(shí)再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);
  }
}

    /**
     * 單例模式就是一個(gè)類只創(chuàng)建一個(gè)實(shí)例，以便節(jié)省開銷和保證統(tǒng)一
     * 對于多線程語言需要注意線程安全和性能之間取得一個(gè)平衡
     */
    SingletonEager singletonEager1 = SingletonEager.getInstance();
    SingletonEager singletonEager2 = SingletonEager.getInstance();
    singletonEager1.run();
    singletonEager2.run();
    // 兩個(gè)實(shí)例相等
    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();

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

// 安全懶漢模式的升級版，通過sync的Mutex實(shí)現(xiàn)雙重檢驗(yàn)
type DoubleCheckSingleton struct {
  name string
}

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

// 定義私有變量，用來保存實(shí)例
var doubleCheckSingletonInstance *DoubleCheckSingleton
var lock = &sync.Mutex{}

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

  return doubleCheckSingletonInstance
}

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

  // 懶漢模式，延遲實(shí)例化，請求實(shí)例時(shí)判斷，如果已經(jīng)實(shí)例化過就直接返回
  // js是單線程語言，無需考慮多線程問題
  static getInstance(alias) {
    if (this.instance === undefined) {
      this.instance = new LazySingleton(alias)
    }
    return this.instance
  }

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

# SingletonSafe.py
from threading import Lock, Thread


# 加鎖的基于元類的單例模式，基于元類type創(chuàng)建的加強(qiáng)版
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)

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

// 靜態(tài)指針，未被創(chuàng)建并分配內(nèi)存空間，指向唯一實(shí)例
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);
}

// 內(nèi)部私有實(shí)例化函數(shù)，不公開
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;

// 非線程安全懶漢模式，延遲初始化。多個(gè)線程同時(shí)調(diào)用函數(shù)時(shí)， 可能會被初始化多次，存在線程不安全問題
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:");
  }

  // 通過加鎖來防止線程并發(fā)導(dǎo)致的不安全
  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;
}