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

news2024/11/25 2:41:31

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

单例模式的原理

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

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

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()
}