当前位置：首页 > news >正文

海南中小企业网站建设智慧宁乡app

news 2025/9/16 12:50:09

海南中小企业网站建设,智慧宁乡app,百度云建网站,品牌的宣传及推广单例模式是一种常用的创建型设计模式，其目的是确保一个类只有一个实例，并提供一个全局访问点。单例模式的原理单例模式的核心在于控制类的实例化过程，通常通过以下方式实现： 私有化构造函数，防止外部直接实例化。…

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

单例模式的原理

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

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

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 {// 私有静态变量，初始值为 nullprivate 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 = Nonedef __new__(cls):if not cls._instance:cls._instance = super(Singleton, cls).__new__(cls)return cls._instancedef do_something(self):print("Doing something...")# 测试
singleton1 = Singleton()
singleton2 = Singleton()print(singleton1 is singleton2)  # 输出 True，表明它们是同一个实例
singleton1.do_something()

Go 实现

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

package mainimport "fmt"type Singleton struct{}var instance *Singletonfunc GetInstance() *Singleton {if instance == nil {instance = &Singleton{}}return instance
}func (s *Singleton) DoSomething() {fmt.Println("Doing something...")
}func main() {singleton := GetInstance()singleton.DoSomething()
}