简介
单例模式(Singleton Pattern)属于创建型设计模式,这种模式只创建一个单一的类,保证一个类只有一个实例,并提供一个访问该实例的全局节点。
当您想控制实例数目,节省系统资源,并不想混用的时候,可以使用单例模式。单例有很多种实现方式,主要分为懒汉和饿汉模式,同时要通过加锁来避免线程安全。不同语言的单例实现略有差异,可以通过查看不同版本的源码来深入理解其中的差异。
不同语言设计模式源码下载:https://github.com/microwind/design-pattern
作用
- 避免全局使用的类频繁地创建与销毁。
- 保证一个类仅有一个实例,并提供一个访问它的全局访问点。
实现步骤
- 创建单例类,注意线程安全
- 返回全局唯一实例
UML
![【单例设计模式原理详解】Java/JS/Go/Python/TS不同语言实现](https://imgs.yssmx.com/Uploads/2023/04/426723-1.png)
Java代码
单例实现,不同语言有很大不同,跟语言特性有关。请查看其他源码进行比较。文章来源:https://www.toymoban.com/news/detail-426723.html
饿汉式(线程安全)
// 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;
}
更多语言版本
不同语言实现设计模式:https://github.com/microwind/design-pattern文章来源地址https://www.toymoban.com/news/detail-426723.html
到了这里,关于【单例设计模式原理详解】Java/JS/Go/Python/TS不同语言实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!