单例模式详解

为什么把它放在设计模式中的第一个？因为它在开发中足够常用，且由于其代码量比较小，面试的时候可是高频重点！

定义

单例模式（Singleton Pattern）是一种创建型设计模式，旨在确保某个类只有一个实例，并提供一个全局访问点。

特点

1. 唯一性：保证一个类只有一个实例。
2. 全局访问：提供对实例的全局访问点。
3. 延迟初始化：仅在需要时创建实例（可选）。

适用场景

• 配置管理：如日志管理器、配置管理器等，需要唯一的全局实例。
• 资源管理：如线程池、数据库连接池。
• 控制访问：如访问计数器、跨模块共享的全局状态。

优缺点

• 优点：

• 降低内存开销。
• 保证全局状态一致性。
• 提供对资源的受控访问。

• 缺点：

• 不适合并发环境（需考虑线程安全）。
• 可能造成代码过度耦合，违反单一职责原则。

使用案例

1. 日志系统：确保只有一个日志文件被写入。
2. 数据库连接池：确保共享同一个连接池实例以提高性能。
3. 配置文件加载器：整个应用程序共享一个配置加载实例。

实现代码

C++ 实现

#include <iostream>
#include <mutex>

class Singleton {
public:
   // 禁用拷贝构造和赋值运算符
   Singleton(const Singleton&) = delete;
   Singleton& operator=(const Singleton&) = delete;

   // 获取唯一实例
   static Singleton& getInstance() {
       static Singleton instance; // 使用C++11的magic static，线程安全
       return instance;
   }

   void doSomething() {
       std::cout << "Doing something in Singleton instance!" << std::endl;
   }

private:
   // 私有化构造函数
   Singleton() {
       std::cout << "Singleton initialized." << std::endl;
   }
};

int main() {
   Singleton& instance = Singleton::getInstance();
   instance.doSomething();
   return 0;
}



C# 实现

using System;

public sealed class Singleton {
   private static readonly Lazy<Singleton> lazyInstance =
       new Lazy<Singleton>(() => new Singleton());

   // 私有化构造函数
   private Singleton() {
       Console.WriteLine("Singleton initialized.");
   }

   public static Singleton Instance => lazyInstance.Value;

   public void DoSomething() {
       Console.WriteLine("Doing something in Singleton instance!");
   }
}

class Program {
   static void Main(string[] args) {
       Singleton instance = Singleton.Instance;
       instance.DoSomething();
   }
}



classDiagram

class Singleton {

   - Singleton instance

   - Singleton()

   + getInstance() Singleton

   + doSomething() void

}

Singleton --> Singleton : instantiates

进一步扩展内容

单例模式的变种

1. 饿汉式单例

• 实现：实例在类加载时初始化。
• 特点：

• 初始化时即创建实例，线程安全。
• 如果实例未使用，会浪费资源。

C++ 实现

class Singleton {
public:
   static Singleton& getInstance() {
       return instance;
   }
   void doSomething() {}

private:
   Singleton() {}
   static Singleton instance; // 静态成员变量
};

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



C# 实现

public sealed class Singleton {
   private static readonly Singleton instance = new Singleton();
   private Singleton() {}
   public static Singleton Instance => instance;
}


2. 懒汉式单例

• 实现：实例在首次调用时创建。
• 特点：

• 延迟初始化，减少资源浪费。
• 需要显式处理线程安全问题。

C++ 实现

#include <mutex>

class Singleton {
public:
   static Singleton* getInstance() {
       if (!instance) {
           std::lock_guard<std::mutex> lock(mutex);
           if (!instance) { // 双重检查锁
               instance = new Singleton();
           }
       }
       return instance;
   }
   void doSomething() {}

private:
   Singleton() {}
   static Singleton* instance;
   static std::mutex mutex;
};

// 初始化静态成员
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;



C# 实现

using System;

public sealed class Singleton {
   private static Singleton instance;
   private static readonly object lockObj = new object();

   private Singleton() {}

   public static Singleton Instance {
       get {
           if (instance == null) {
               lock (lockObj) {
                   if (instance == null) { // 双重检查锁
                       instance = new Singleton();
                   }
               }
           }
           return instance;
       }
   }
}



3. 静态内部类单例（Java风格，C++/C# 不常用）

• 实现：依赖于类加载的线程安全特性。
• 特点：

• 利用静态内部类，确保延迟加载和线程安全。
• C++/C# 的类似实现可以通过 magic static 或 Lazy<T> 实现。

线程安全的实现细节

问题来源

• 多线程环境中，多个线程可能同时创建实例，导致非唯一性或线程死锁。

解决方案

1. **C++11 的 magic static**：

• 静态变量的初始化线程安全。

static Singleton& getInstance() {
   static Singleton instance;
   return instance;
}


1. 双重检查锁（DCL）：

• 适用于懒汉式单例。
• 减少锁的频率，提高效率。

2. **C# 的 Lazy<T>**：

• 提供线程安全的延迟初始化机制。

private static readonly Lazy<Singleton> instance =
   new Lazy<Singleton>(() => new Singleton());


单例模式与依赖注入（DI）

依赖注入（DI）的定义

依赖注入是一种设计模式，通过将类的依赖项通过构造函数、属性或方法传入，而不是类自己创建依赖对象。

区别

结合使用

单例模式和依赖注入并不冲突，单例实例可以作为依赖注入的一部分：

• 容器管理单例实例：通过 DI 容器将单例模式封装，避免手动管理实例。

services.AddSingleton<Singleton>();


示例

在 ASP.NET Core 中：

public interface ILoggerService {
   void Log(string message);
}

public class SingletonLogger : ILoggerService {
   public void Log(string message) {
       Console.WriteLine($"Log: {message}");
   }
}

// 注册单例
services.AddSingleton<ILoggerService, SingletonLogger>();

// 使用
public class SomeService {
   private readonly ILoggerService _logger;
   public SomeService(ILoggerService logger) {
       _logger = logger;
   }

   public void DoWork() {
       _logger.Log("Work in progress.");
   }
}