簡介
單例模式（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/p/%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.uj5u.com/ruanti/551374.html
標籤：設計模式
下一篇：返回列表