单例设计模式（Singleton Pattern）是一种常用的设计模式，确保一个类只有一个实例，并提供一个全局访问点。单例模式在需要限制实例数量的场景中非常有用，例如数据库连接、日志记录器等。本文将介绍如何在 TypeScript 中实现单例设计模式。
什么是单例设计模式？
单例设计模式的核心思想是通过控制实例的创建过程，确保一个类只有一个实例，并且提供一种全局访问该实例的方式。单例模式具有以下几个特点：
- 唯一性：一个类只有一个实例。
- 全局访问：提供一个全局访问点。
- 延迟实例化：实例在第一次使用时创建。
单例设计模式有两种主要实现方式：饿汉式（Eager Initialization）和懒汉式（Lazy Initialization）。这两种实现方式的区别主要在于实例的创建时机。下面我们详细分析这两种方式，并给出它们在 TypeScript 中的实现。
饿汉式单例模式
饿汉式单例模式在类加载时就创建实例，不管是否需要该实例。这种方式简单直观，但在类加载时即实例化，可能会导致资源浪费。
优点：
- 实现简单，避免了多线程同步问题。
- 类加载时就创建实例，响应速度快。
缺点：
- 如果实例一直未被使用，会浪费内存。
实现方式：
class EagerSingleton {
// 在类加载时实例化
private static instance: EagerSingleton = new EagerSingleton();
// 私有构造函数，防止外部实例化
private constructor() {
// 初始化代码
}
// 静态方法，提供全局访问点
public static getInstance(): EagerSingleton {
return EagerSingleton.instance;
}
// 示例方法
public showMessage(): void {
console.log("Hello, Eager Singleton!");
}
}
// 使用单例
const eagerSingleton1 = EagerSingleton.getInstance();
const eagerSingleton2 = EagerSingleton.getInstance();
eagerSingleton1.showMessage(); // 输出 "Hello, Eager Singleton!"
console.log(eagerSingleton1 === eagerSingleton2); // 输出 true，说明两个引用是同一个实例
懒汉式单例模式
懒汉式单例模式在首次需要实例时才创建实例。这种方式延迟了实例化时机，避免了不必要的资源浪费，但在多线程环境下需要注意同步问题。
优点：
- 延迟实例化，资源利用率高。
- 只有在需要时才创建实例，节省内存。
缺点：
- 需要考虑多线程同步问题，可能会增加复杂性。
实现方式：
class LazySingleton {
private static instance: LazySingleton | null = null;
// 私有构造函数，防止外部实例化
private constructor() {
// 初始化代码
}
// 静态方法，用于获取唯一实例
public static getInstance(): LazySingleton {
if (LazySingleton.instance === null) {
LazySingleton.instance = new LazySingleton();
}
return LazySingleton.instance;
}
// 示例方法
public showMessage(): void {
console.log("Hello, Lazy Singleton!");
}
}
// 使用单例
const lazySingleton1 = LazySingleton.getInstance();
const lazySingleton2 = LazySingleton.getInstance();
lazySingleton1.showMessage(); // 输出 "Hello, Lazy Singleton!"
console.log(lazySingleton1 === lazySingleton2); // 输出 true，说明两个引用是同一个实例
懒汉式单例模式（线程安全）
在多线程环境中，懒汉式单例模式需要确保线程安全。我们可以使用 synchronized 或其他同步机制来保证线程安全。
实现方式（使用双重检查锁定）：
class ThreadSafeLazySingleton {
private static instance: ThreadSafeLazySingleton | null = null;
// 私有构造函数，防止外部实例化
private constructor() {
// 初始化代码
}
// 静态方法，用于获取唯一实例（双重检查锁定）
public static getInstance(): ThreadSafeLazySingleton {
if (ThreadSafeLazySingleton.instance === null) {
// 添加锁定，确保线程安全
synchronized (ThreadSafeLazySingleton) {
if (ThreadSafeLazySingleton.instance === null) {
ThreadSafeLazySingleton.instance = new ThreadSafeLazySingleton();
}
}
}
return ThreadSafeLazySingleton.instance;
}
// 示例方法
public showMessage(): void {
console.log("Hello, Thread-Safe Lazy Singleton!");
}
}
// 使用单例
const threadSafeSingleton1 = ThreadSafeLazySingleton.getInstance();
const threadSafeSingleton2 = ThreadSafeLazySingleton.getInstance();
threadSafeSingleton1.showMessage(); // 输出 "Hello, Thread-Safe Lazy Singleton!"
console.log(threadSafeSingleton1 === threadSafeSingleton2); // 输出 true，说明两个引用是同一个实例
注意： synchronized 是 Java 中的关键字，TypeScript 中并没有直接的同步机制。我们可以使用其他方式来模拟线程安全，例如 Mutex 库或者其他同步原语。
结论
饿汉式和懒汉式单例模式各有优缺点，适用于不同的场景。饿汉式简单直观，适用于实例初始化开销小且使用频繁的场景；懒汉式延迟实例化，适用于实例初始化开销大且不一定会用到的场景。结合实际需求选择合适的单例模式实现，可以有效提高代码的性能和资源利用率。
希望本文能帮助你更好地理解和实现单例设计模式。如果有任何问题或建议，欢迎讨论！
