(相关资料图)

简介

单例模式（Singleton Pattern）属于创建型设计模式，这种模式只创建一个单一的类，保证一个类只有一个实例，并提供一个访问该实例的全局节点。

当您想控制实例数目，节省系统资源，并不想混用的时候，可以使用单例模式。单例有很多种实现方式，主要分为懒汉和饿汉模式，同时要通过加锁来避免线程安全。不同语言的单例实现略有差异，可以通过查看不同版本的源码来深入理解其中的差异。

作用

1. 避免全局使用的类频繁地创建与销毁。
2. 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

实现步骤

1. 创建单例类，注意线程安全
2. 返回全局唯一实例

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.goimport (  "fmt"  "sync")// 安全懒汉模式的升级版，通过sync的Mutex实现双重检验type DoubleCheckSingleton struct {  name string}func (s *DoubleCheckSingleton) Run() {  fmt.Println("DoubleCheckSingleton::run()", s.name)}// 定义私有变量，用来保存实例var doubleCheckSingletonInstance *DoubleCheckSingletonvar 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.jsexport 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.pyfrom 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 // 静态指针，未被创建并分配内存空间，指向唯一实例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;}

更多语言版本

不同语言实现设计模式：https://github.com/microwind/design-pattern