【设计模式】【创建型模式（Creational Patterns）】之单例模式

单例模式是一种常用的创建型设计模式，其目的是确保一个类只有一个实例，并提供一个全局访问点。

单例模式的原理

单例模式的核心在于控制类的实例化过程，通常通过以下方式实现：

私有化构造函数，防止外部直接实例化。
提供一个静态方法或属性，用于返回类的唯一实例。
使用懒汉式或饿汉式初始化策略来创建实例。

UML 类图

下面是单例模式的UML类图：

复制代码

+-----------------+
| Singleton       |
+-----------------+
| -instance: Singleton |
+-----------------+
| +getInstance(): Singleton |
| +doSomething(): void    |
+-----------------+

在这个UML类图中：

Singleton 类有一个私有的静态变量 instance，用来存储唯一的实例。
getInstance() 方法是一个静态方法，用于获取 Singleton 类的唯一实例。
doSomething() 是一个普通的方法，用于演示单例对象的功能。

Java 代码示例

这里提供两种常见的单例模式实现方式：懒汉式和饿汉式。

饿汉式（线程安全，加载速度较慢）

复制代码

public class Singleton {
    // 在静态初始化器中创建实例，保证线程安全
    private static final Singleton INSTANCE = new Singleton();

    // 私有构造函数，防止外部实例化
    private Singleton() {}

    // 公共静态方法，提供全局访问点
    public static Singleton getInstance() {
        return INSTANCE;
    }

    // 示例方法
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

懒汉式（线程安全，延迟加载）

复制代码

public class Singleton {
    // 私有静态变量，初始值为 null
    private static Singleton instance;

    // 私有构造函数，防止外部实例化
    private Singleton() {}

    // 公共静态方法，提供全局访问点
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    // 示例方法
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

懒汉式优化：双重检查锁定（Double-Checked Locking）

为了提高性能，可以使用双重检查锁定来减少同步锁的开销：

复制代码

public class Singleton {
    // 使用 volatile 关键字确保多线程环境下的可见性
    private static volatile Singleton instance;

    // 私有构造函数，防止外部实例化
    private Singleton() {}

    // 公共静态方法，提供全局访问点
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    // 示例方法
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

C++ 实现

在 C++ 中，我们可以使用静态成员变量和静态成员函数来实现单例模式。

复制代码

#include <iostream>

class Singleton {
private:
    // 私有构造函数，防止外部实例化
    Singleton() {}

    // 删除拷贝构造函数和赋值操作符，防止拷贝
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 静态成员变量，存储唯一的实例
    static Singleton* instance;

public:
    // 静态成员函数，提供全局访问点
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    // 示例方法
    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;

int main() {
    Singleton* singleton = Singleton::getInstance();
    singleton->doSomething();
    return 0;
}

Python 实现

在 Python 中，可以通过模块级别的全局变量来实现单例模式，也可以使用装饰器或者元类。

复制代码

class Singleton:
    _instance = None

    def __new__(cls):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

    def do_something(self):
        print("Doing something...")

# 测试
singleton1 = Singleton()
singleton2 = Singleton()

print(singleton1 is singleton2)  # 输出 True，表明它们是同一个实例
singleton1.do_something()

Go 实现

在 Go 中，可以使用包级变量来实现单例模式。

复制代码

package main

import "fmt"

type Singleton struct{}

var instance *Singleton

func GetInstance() *Singleton {
    if instance == nil {
        instance = &Singleton{}
    }
    return instance
}

func (s *Singleton) DoSomething() {
    fmt.Println("Doing something...")
}

func main() {
    singleton := GetInstance()
    singleton.DoSomething()
}

解释

C++：使用了静态成员变量和静态成员函数来确保单例的唯一性和全局可访问性。同时删除了拷贝构造函数和赋值操作符，防止拷贝。
Python ：使用了类的 __new__ 方法来控制实例的创建，确保只有一个实例存在。
Go ：使用了包级变量 instance 来存储唯一的实例，并通过 GetInstance 函数来提供全局访问点。

总结

这些实现都遵循了单例模式的基本原则：确保一个类只有一个实例，并提供一个全局访问点。每种语言的实现方式有所不同，但核心思想是一致的。