设计模式(C++)详解—单例模式(1)

<摘要>
单例模式是创建型设计模式中最经典且应用最广泛的设计模式之一，它确保一个类只有一个实例并提供全局访问点。本文从历史背景和核心概念出发，详细阐述了单例模式的产生背景和演进历程，深入剖析了其在资源管理、状态一致性和访问控制方面的设计意图。通过饿汉式、懒汉式、Meyer’s Singleton和线程安全双检锁等四种经典实现方式的对比分析，结合日志系统、配置管理、数据库连接池等实际应用场景，提供了完整的可编译运行代码示例和Makefile配置。文章特别针对多线程环境下的线程安全问题进行了深度解析，使用时序图和状态图直观演示了竞态条件的产生与解决方案，最后探讨了单例模式的测试策略和替代方案，为开发者提供了全面而实用的指导。

<解析>

1. 背景与核心概念

1.1 产生背景与发展脉络

单例模式（Singleton Pattern）的诞生源于软件开发中对特定类型对象管理的实际需求。在早期的软件开发实践中，开发者逐渐意识到某些类的实例应该在整个应用程序生命周期中只存在一个，这种需求催生了单例模式的形成。

历史演进阶段：

1. 初期探索阶段（1980年代前）：在面向对象编程范式普及之前，开发者通常使用全局变量来实现类似单例的功能。这种方式虽然简单，但带来了命名冲突、初始化顺序不确定和访问控制缺失等问题。

2. 模式化阶段（1980-1990年代）：随着"Gang of Four"（Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides）在1994年出版的《设计模式：可复用面向对象软件的基础》一书中正式提出单例模式，它被系统性地归纳为23种经典设计模式之一，属于创建型模式类别。

3. 语言特性融合阶段（2000年代至今）：随着编程语言的发展，单例模式的实现方式不断演进。C++11标准引入的线程局部存储（thread_local）、原子操作（atomic）和静态变量初始化线程安全等特性，为单例模式提供了更优雅的实现方案。

产生的根本原因：

• 资源共享需求：如数据库连接池、线程池等需要集中管理的资源
• 状态一致性要求：如配置管理、计数器等需要全局一致状态的对象
• 性能优化考虑：避免频繁创建销毁重量级对象带来的开销
• 访问控制需要：集中管控对特定资源的访问，如日志系统

1.2 核心概念与关键术语

单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局访问点来获取该实例的设计模式。

关键特性：

• 唯一实例性（Instance Uniqueness）：保证类只有一个实例存在
• 全局可访问性（Global Accessibility）：提供统一的访问入口
• 延迟初始化（Lazy Initialization）：多数实现支持在第一次使用时创建实例
• 线程安全性（Thread Safety）：在多线程环境下保证正确性

基本结构组件：

class Singleton {
private:
    static Singleton* instance;    // 静态私有成员，保存唯一实例
    Singleton();                   // 私有构造函数，防止外部实例化
    Singleton(const Singleton&) = delete;            // 删除拷贝构造函数
    Singleton& operator=(const Singleton&) = delete; // 删除赋值运算符
    
public:
    static Singleton* getInstance(); // 静态公共方法，提供全局访问点
    // 其他成员函数...
};

UML表示：

图1.1：单例模式基本UML类图

2. 设计意图与考量

2.1 核心设计目标

单例模式的设计旨在解决以下核心问题：

2.1.1 controlled Instance Creation（受控实例创建）
通过将构造函数设为私有，单例模式彻底消除了客户端随意创建类实例的可能性。这种强制性的创建控制确保了实例数量的严格管理，从语言机制层面而非仅仅约定层面保证了单一实例的约束。

2.1.2 Global Access Point（全局访问点）
提供静态方法getInstance()作为获取单例实例的统一入口，解决了全局变量方式的散乱访问问题。这种方法：

• 明确了职责：清晰标识这是获取实例的正确方式
• 封装了复杂性：隐藏了实例创建和管理的细节
• 提供了灵活性：允许在不改变客户端代码的情况下修改实例化策略

2.1.3 Resource Coordination（资源协调）
对于需要协调共享资源的场景，单例模式提供了自然的设计方案：

• 避免资源冲突：如多个日志写入器同时写文件可能导致的内容交错
• 减少资源浪费：如数据库连接的重用而非重复创建
• 统一管理策略：如缓存的一致性管理和过期策略

2.2 设计考量因素

2.2.1 线程安全性考量
在多线程环境下，单例模式的实现必须考虑竞争条件（Race Condition）问题：

图2.1：多线程环境下的竞态条件时序图

解决方案包括：

• 饿汉式初始化：在程序启动时即创建实例，避免运行时竞争
• 互斥锁保护：在懒汉式初始化时使用锁机制
• 双检锁模式：减少锁的使用频率，提高性能
• 局部静态变量：利用C++11的静态变量线程安全特性

2.2.2 初始化时机权衡

2.2.3 继承与扩展性
单例类的继承会带来设计上的挑战：

• 构造函数隐私性：派生类需要访问基类构造函数
• 实例唯一性：每个派生类是否都应该是单例？
• 模板方法应用：通过模板元编程实现可复用的单例基类

2.2.4 测试困难性
单例模式对单元测试不友好，主要原因：

• 全局状态共享：测试用例之间可能相互影响
• 难以模拟：无法轻松替换为模拟对象进行测试
• 重置困难：需要额外机制在测试间重置单例状态

2.2.5 生命周期管理
单例实例的生命周期管理需要考虑：

• 创建时机：何时以及如何创建实例
• 销毁时机：是否需要显式销毁，如何保证安全销毁
• 依赖关系：单例之间的依赖关系及初始化顺序

3. 实例与应用场景

3.1 日志系统（Logger）

应用场景：
在大多数应用程序中，日志系统需要满足以下要求：

• 全局唯一：多个模块共享同一个日志实例
• 线程安全：多线程环境下能安全写入日志
• 集中配置：统一设置日志级别、输出目标等

完整实现代码：

// logger.h
#ifndef LOGGER_H
#define LOGGER_H

#include <iostream>
#include <string>
#include <mutex>
#include <fstream>

enum class LogLevel {
    DEBUG,
    INFO,
    WARNING,
    ERROR,
    CRITICAL
};

class Logger {
public:
    static Logger& getInstance();
    
    void setLogLevel(LogLevel level);
    void setLogFile(const std::string& filename);
    void log(const std::string& message, LogLevel level = LogLevel::INFO);
    
    // 删除拷贝构造函数和赋值运算符
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;

private:
    Logger();
    ~Logger();
    
    std::string getLevelString(LogLevel level) const;
    
    static Logger* instance;
    static std::mutex mutex;
    
    LogLevel currentLevel;
    std::ofstream logFile;
    std::ostream* outputStream;
    bool useFile;
};

#endif // LOGGER_H

// logger.cpp
#include "logger.h"
#include <iostream>
#include <chrono>
#include <iomanip>

Logger* Logger::instance = nullptr;
std::mutex Logger::mutex;

Logger::Logger() : currentLevel(LogLevel::INFO), useFile(false), outputStream(&std::cout) {
    std::cout << "Logger initialized" << std::endl;
}

Logger::~Logger() {
    if (logFile.is_open()) {
        logFile.close();
    }
    std::cout << "Logger destroyed" << std::endl;
}

Logger& Logger::getInstance() {
    std::lock_guard<std::mutex> lock(mutex);
    if (instance == nullptr) {
        instance = new Logger();
    }
    return *instance;
}

void Logger::setLogLevel(LogLevel level) {
    currentLevel = level;
}

void Logger::setLogFile(const std::string& filename) {
    std::lock_guard<std::mutex> lock(mutex);
    if (logFile.is_open()) {
        logFile.close();
    }
    
    logFile.open(filename, std::ios::out | std::ios::app);
    if (logFile.is_open()) {
        useFile = true;
        outputStream = &logFile;
    } else {
        useFile = false;
        outputStream = &std::cout;
        std::cerr << "Failed to open log file: " << filename << std::endl;
    }
}

void Logger::log(const std::string& message, LogLevel level) {
    if (level < currentLevel) {
        return;
    }
    
    std::lock_guard<std::mutex> lock(mutex);
    
    // 获取当前时间
    auto now = std::chrono::system_clock::now();
    auto time = std::chrono::system_clock::to_time_t(now);
    
    *outputStream << "[" << std::put_time(std::localtime(&time), "%Y-%m-%d %H:%M:%S") << "] "
                 << "[" << getLevelString(level) << "] "
                 << message << std::endl;
}

std::string Logger::getLevelString(LogLevel level) const {
    switch (level) {
        case LogLevel::DEBUG: return "DEBUG";
        case LogLevel::INFO: return "INFO";
        case LogLevel::WARNING: return "WARNING";
        case LogLevel::ERROR: return "ERROR";
        case LogLevel::CRITICAL: return "CRITICAL";
        default: return "UNKNOWN";
    }
}

// main_logger.cpp
#include "logger.h"
#include <thread>
#include <vector>

void logMessages(int threadId) {
    for (int i = 0; i < 5; ++i) {
        std::string message = "Thread " + std::to_string(threadId) + " - Message " + std::to_string(i);
        Logger::getInstance().log(message, LogLevel::INFO);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

int main() {
    // 设置日志级别和输出文件
    Logger::getInstance().setLogLevel(LogLevel::DEBUG);
    Logger::getInstance().setLogFile("application.log");
    
    Logger::getInstance().log("Application started", LogLevel::INFO);
    
    // 创建多个线程测试线程安全性
    std::vector<std::thread> threads;
    for (int i = 0; i < 3; ++i) {
        threads.emplace_back(logMessages, i);
    }
    
    for (auto& thread : threads) {
        thread.join();
    }
    
    Logger::getInstance().log("Application finished", LogLevel::INFO);
    
    return 0;
}

Makefile配置：

# Makefile for Logger example
CXX = g++
CXXFLAGS = -std=c++11 -pthread -Wall -Wextra

TARGET = logger_example
SOURCES = main_logger.cpp logger.cpp
HEADERS = logger.h

$(TARGET): $(SOURCES) $(HEADERS)
	$(CXX) $(CXXFLAGS) -o $(TARGET) $(SOURCES)

clean:
	rm -f $(TARGET) application.log

run: $(TARGET)
	./$(TARGET)

.PHONY: clean run

编译运行：

make        # 编译程序
make run    # 运行程序

3.2 配置管理器（Configuration Manager）

应用场景：
应用程序通常需要读取和管理配置文件，配置管理器应该：

• 全局唯一：确保所有模块使用相同的配置
• 懒加载：只在第一次使用时加载配置
• 线程安全：支持多线程并发读取配置

完整实现代码：

// config_manager.h
#ifndef CONFIG_MANAGER_H
#define CONFIG_MANAGER_H

#include <string>
#include <unordered_map>
#include <mutex>
#include <memory>

class ConfigManager {
public:
    static ConfigManager& getInstance();
    
    bool loadConfig(const std::string& filename);
    std::string getString(const std::string& key, const std::string& defaultValue = "") const;
    int getInt(const std::string& key, int defaultValue = 0) const;
    double getDouble(const std::string& key, double defaultValue = 0.0) const;
    bool getBool(const std::string& key, bool defaultValue = false) const;
    
    void setString(const std::string& key, const std::string& value);
    void setInt(const std::string& key, int value);
    void setDouble(const std::string& key, double value);
    void setBool(const std::string& key, bool value);
    
    bool saveConfig(const std::string& filename) const;
    
    // 删除拷贝构造函数和赋值运算符
    ConfigManager(const ConfigManager&) = delete;
    ConfigManager& operator=(const ConfigManager&) = delete;

private:
    ConfigManager();
    ~ConfigManager() = default;
    
    void parseLine(const std::string& line);
    void setDefaultValues();
    
    mutable std::mutex configMutex;
    std::unordered_map<std::string, std::string> configMap;
    std::string configFileName;
};

#endif // CONFIG_MANAGER_H

// config_manager.cpp
#include "config_manager.h"
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <cctype>

ConfigManager& ConfigManager::getInstance() {
    static ConfigManager instance;
    return instance;
}

ConfigManager::ConfigManager() {
    setDefaultValues();
}

void ConfigManager::setDefaultValues() {
    std::lock_guard<std::mutex> lock(configMutex);
    configMap["server.host"] = "localhost";
    configMap["server.port"] = "8080";
    configMap["database.enabled"] = "true";
    configMap["log.level"] = "info";
    configMap["cache.size"] = "100";
}

bool ConfigManager::loadConfig(const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        std::cerr << "Failed to open config file: " << filename << std::endl;
        return false;
    }
    
    std::lock_guard<std::mutex> lock(configMutex);
    configFileName = filename;
    configMap.clear();
    setDefaultValues(); // 重新设置默认值
    
    std::string line;
    while (std::getline(file, line)) {
        // 移除行首尾的空白字符
        line.erase(0, line.find_first_not_of(" \t"));
        line.erase(line.find_last_not_of(" \t") + 1);
        
        // 跳过空行和注释
        if (line.empty() || line[0] == '#') {
            continue;
        }
        
        parseLine(line);
    }
    
    file.close();
    return true;
}

void ConfigManager::parseLine(const std::string& line) {
    size_t equalsPos = line.find('=');
    if (equalsPos == std::string::npos) {
        return; // 无效行
    }
    
    std::string key = line.substr(0, equalsPos);
    std::string value = line.substr(equalsPos + 1);
    
    // 移除key和value首尾的空白字符
    key.erase(0, key.find_first_not_of(" \t"));
    key.erase(key.find_last_not_of(" \t") + 1);
    
    value.erase(0, value.find_first_not_of(" \t"));
    value.erase(value.find_last_not_of(" \t") + 1);
    
    // 移除value可能的引号
    if (!value.empty()) {
        if ((value.front() == '"' && value.back() == '"') ||
            (value.front() == '\'' && value.back() == '\'')) {
            value = value.substr(1, value.size() - 2);
        }
    }
    
    if (!key.empty()) {
        configMap[key] = value;
    }
}

std::string ConfigManager::getString(const std::string& key, const std::string& defaultValue) const {
    std::lock_guard<std::mutex> lock(configMutex);
    auto it = configMap.find(key);
    return it != configMap.end() ? it->second : defaultValue;
}

int ConfigManager::getInt(const std::string& key, int defaultValue) const {
    std::string value = getString(key, "");
    if (value.empty()) {
        return defaultValue;
    }
    
    try {
        return std::stoi(value);
    } catch (...) {
        return defaultValue;
    }
}

double ConfigManager::getDouble(const std::string& key, double defaultValue) const {
    std::string value = getString(key, "");
    if (value.empty()) {
        return defaultValue;
    }
    
    try {
        return std::stod(value);
    } catch (...) {
        return defaultValue;
    }
}

bool ConfigManager::getBool(const std::string& key, bool defaultValue) const {
    std::string value = getString(key, "");
    if (value.empty()) {
        return defaultValue;
    }
    
    // 转换为小写进行比较
    std::string lowerValue;
    std::transform(value.begin(), value.end(), std::back_inserter(lowerValue),
                  [](unsigned char c) { return std::tolower(c); });
    
    if (lowerValue == "true" || lowerValue == "yes" || lowerValue == "1") {
        return true;
    } else if (lowerValue == "false" || lowerValue == "no" || lowerValue == "0") {
        return false;
    }
    
    return defaultValue;
}

void ConfigManager::setString(const std::string& key, const std::string& value) {
    std::lock_guard<std::mutex> lock(configMutex);
    configMap[key] = value;
}

void ConfigManager::setInt(const std::string& key, int value) {
    setString(key, std::to_string(value));
}

void ConfigManager::setDouble(const std::string& key, double value) {
    setString(key, std::to_string(value));
}

void ConfigManager::setBool(const std::string& key, bool value) {
    setString(key, value ? "true" : "false");
}

bool ConfigManager::saveConfig(const std::string& filename) const {
    std::ofstream file(filename);
    if (!file.is_open()) {
        return false;
    }
    
    std::lock_guard<std::mutex> lock(configMutex);
    for (const auto& pair : configMap) {
        file << pair.first << " = " << pair.second << std::endl;
    }
    
    file.close();
    return true;
}

// main_config.cpp
#include "config_manager.h"
#include <iostream>
#include <thread>

void printConfig(const std::string& threadName) {
    auto& config = ConfigManager::getInstance();
    
    std::cout << threadName << " - Server: " 
              << config.getString("server.host") << ":" 
              << config.getInt("server.port") << std::endl;
              
    std::cout << threadName << " - Database enabled: " 
              << std::boolalpha << config.getBool("database.enabled") << std::endl;
              
    std::cout << threadName << " - Log level: " 
              << config.getString("log.level") << std::endl;
              
    std::cout << threadName << " - Cache size: " 
              << config.getInt("cache.size") << " MB" << std::endl;
}

void configReader(int threadId) {
    std::string threadName = "Thread_" + std::to_string(threadId);
    printConfig(threadName);
}

int main() {
    // 创建示例配置文件
    std::ofstream configFile("app.conf");
    configFile << "# Application configuration\n";
    configFile << "server.host = 192.168.1.100\n";
    configFile << "server.port = 9090\n";
    configFile << "database.enabled = true\n";
    configFile << "log.level = debug\n";
    configFile << "cache.size = 256\n";
    configFile.close();
    
    // 加载配置文件
    if (!ConfigManager::getInstance().loadConfig("app.conf")) {
        std::cerr << "Failed to load configuration" << std::endl;
        return 1;
    }
    
    std::cout << "Main thread - Configuration loaded successfully\n";
    
    // 创建多个线程读取配置
    std::thread threads[3];
    for (int i = 0; i < 3; ++i) {
        threads[i] = std::thread(configReader, i);
    }
    
    // 修改一些配置值
    ConfigManager::getInstance().setString("server.host", "10.0.0.1");
    ConfigManager::getInstance().setInt("server.port", 8080);
    
    for (int i = 0; i < 3; ++i) {
        threads[i].join();
    }
    
    // 保存当前配置
    if (ConfigManager::getInstance().saveConfig("app_modified.conf")) {
        std::cout << "Configuration saved to app_modified.conf" << std::endl;
    }
    
    return 0;
}

Makefile配置：

# Makefile for Config Manager example
CXX = g++
CXXFLAGS = -std=c++11 -pthread -Wall -Wextra

TARGET = config_example
SOURCES = main_config.cpp config_manager.cpp
HEADERS = config_manager.h

$(TARGET): $(SOURCES) $(HEADERS)
	$(CXX) $(CXXFLAGS) -o $(TARGET) $(SOURCES)

clean:
	rm -f $(TARGET) app.conf app_modified.conf

run: $(TARGET)
	./$(TARGET)

.PHONY: clean run

编译运行：

make        # 编译程序
make run    # 运行程序

3.3 数据库连接池（Database Connection Pool）

应用场景：
数据库连接是昂贵的资源，连接池需要：

• 限制连接数量：防止过多连接耗尽数据库资源
• 重用连接：避免频繁创建和关闭连接
• 全局管理：所有数据库操作共享同一个连接池

完整实现代码：

// connection_pool.h
#ifndef CONNECTION_POOL_H
#define CONNECTION_POOL_H

#include <queue>
#include <memory>
#include <mutex>
#include <condition_variable>
#include <string>
#include <functional>

// 模拟数据库连接类
class DatabaseConnection {
public:
    DatabaseConnection(const std::string& connectionString) 
        : connectionString(connectionString), connected(false) {
        connect();
    }
    
    ~DatabaseConnection() {
        disconnect();
    }
    
    bool execute(const std::string& query) {
        if (!connected) {
            return false;
        }
        // 模拟查询执行
        std::cout << "Executing query: " << query << std::endl;
        return true;
    }
    
    bool isConnected() const {
        return connected;
    }
    
    void disconnect() {
        if (connected) {
            std::cout << "Disconnecting from database" << std::endl;
            connected = false;
        }
    }

private:
    bool connect() {
        std::cout << "Connecting to database: " << connectionString << std::endl;
        // 模拟连接耗时
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        connected = true;
        return true;
    }
    
    std::string connectionString;
    bool connected;
};

class ConnectionPool {
public:
    static ConnectionPool& getInstance();
    
    void initialize(size_t maxSize, const std::string& connectionString);
    
    std::shared_ptr<DatabaseConnection> getConnection();
    void returnConnection(DatabaseConnection* connection);
    
    size_t availableCount() const;
    size_t inUseCount() const;
    
    // 删除拷贝构造函数和赋值运算符
    ConnectionPool(const ConnectionPool&) = delete;
    ConnectionPool& operator=(const ConnectionPool&) = delete;

private:
    ConnectionPool();
    ~ConnectionPool();
    
    mutable std::mutex poolMutex;
    std::condition_variable connectionAvailable;
    
    std::queue<DatabaseConnection*> availableConnections;
    std::vector<DatabaseConnection*> allConnections;
    
    size_t maxPoolSize;
    std::string connectionString;
    bool initialized;
};

#endif // CONNECTION_POOL_H

// connection_pool.cpp
#include "connection_pool.h"
#include <iostream>
#include <algorithm>

ConnectionPool& ConnectionPool::getInstance() {
    static ConnectionPool instance;
    return instance;
}

ConnectionPool::ConnectionPool() 
    : maxPoolSize(0), initialized(false) {
}

ConnectionPool::~ConnectionPool() {
    std::lock_guard<std::mutex> lock(poolMutex);
    for (auto conn : allConnections) {
        delete conn;
    }
    allConnections.clear();
    while (!availableConnections.empty()) {
        availableConnections.pop();
    }
}

void ConnectionPool::initialize(size_t maxSize, const std::string& connString) {
    std::lock_guard<std::mutex> lock(poolMutex);
    if (initialized) {
        return;
    }
    
    maxPoolSize = maxSize;
    connectionString = connString;
    initialized = true;
    
    // 预先创建一些连接
    for (size_t i = 0; i < std::min(size_t(2), maxSize); ++i) {
        auto conn = new DatabaseConnection(connectionString);
        availableConnections.push(conn);
        allConnections.push_back(conn);
    }
}

std::shared_ptr<DatabaseConnection> ConnectionPool::getConnection() {
    std::unique_lock<std::mutex> lock(poolMutex);
    
    if (!initialized) {
        throw std::runtime_error("Connection pool not initialized");
    }
    
    // 等待可用连接
    connectionAvailable.wait(lock, [this]() {
        return !availableConnections.empty() || allConnections.size() < maxPoolSize;
    });
    
    if (!availableConnections.empty()) {
        auto conn = availableConnections.front();
        availableConnections.pop();
        
        return std::shared_ptr<DatabaseConnection>(conn, 
            [this](DatabaseConnection* conn) { returnConnection(conn); });
    }
    
    if (allConnections.size() < maxPoolSize) {
        auto conn = new DatabaseConnection(connectionString);
        allConnections.push_back(conn);
        
        return std::shared_ptr<DatabaseConnection>(conn, 
            [this](DatabaseConnection* conn) { returnConnection(conn); });
    }
    
    throw std::runtime_error("Failed to get database connection");
}

void ConnectionPool::returnConnection(DatabaseConnection* connection) {
    {
        std::lock_guard<std::mutex> lock(poolMutex);
        if (connection->isConnected()) {
            availableConnections.push(connection);
        } else {
            // 移除无效连接
            auto it = std::find(allConnections.begin(), allConnections.end(), connection);
            if (it != allConnections.end()) {
                allConnections.erase(it);
            }
            delete connection;
        }
    }
    connectionAvailable.notify_one();
}

size_t ConnectionPool::availableCount() const {
    std::lock_guard<std::mutex> lock(poolMutex);
    return availableConnections.size();
}

size_t ConnectionPool::inUseCount() const {
    std::lock_guard<std::mutex> lock(poolMutex);
    return allConnections.size() - availableConnections.size();
}

// main_connection_pool.cpp
#include "connection_pool.h"
#include <iostream>
#include <thread>
#include <vector>

void databaseTask(int taskId) {
    try {
        auto& pool = ConnectionPool::getInstance();
        auto connection = pool.getConnection();
        
        std::cout << "Task " << taskId << " got connection. "
                  << "Available: " << pool.availableCount() 
                  << ", In use: " << pool.inUseCount() << std::endl;
        
        // 模拟数据库操作
        connection->execute("SELECT * FROM users WHERE id = " + std::to_string(taskId));
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
        
        std::cout << "Task " << taskId << " releasing connection" << std::endl;
        
    } catch (const std::exception& e) {
        std::cerr << "Task " << taskId << " failed: " << e.what() << std::endl;
    }
}

int main() {
    // 初始化连接池
    ConnectionPool::getInstance().initialize(5, "host=localhost;dbname=test;user=root");
    
    std::cout << "Connection pool initialized. Max size: 5" << std::endl;
    std::cout << "Initial available connections: " 
              << ConnectionPool::getInstance().availableCount() << std::endl;
    
    // 创建多个任务并发使用连接
    std::vector<std::thread> tasks;
    for (int i = 0; i < 10; ++i) {
        tasks.emplace_back(databaseTask, i);
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
    
    for (auto& task : tasks) {
        task.join();
    }
    
    std::cout << "All tasks completed." << std::endl;
    std::cout << "Final available connections: " 
              << ConnectionPool::getInstance().availableCount() << std::endl;
    
    return 0;
}

Makefile配置：

# Makefile for Connection Pool example
CXX = g++
CXXFLAGS = -std=c++11 -pthread -Wall -Wextra

TARGET = connection_pool_example
SOURCES = main_connection_pool.cpp connection_pool.cpp
HEADERS = connection_pool.h

$(TARGET): $(SOURCES) $(HEADERS)
	$(CXX) $(CXXFLAGS) -o $(TARGET) $(SOURCES)

clean:
	rm -f $(TARGET)

run: $(TARGET)
	./$(TARGET)

.PHONY: clean run

编译运行：

make        # 编译程序
make run    # 运行程序

4. 交互性内容解析

4.1 多线程环境下的交互分析

单例模式在多线程环境下的行为复杂性主要体现在实例化过程中。以下通过时序图详细分析不同实现方式的线程交互：

4.1.1 不安全懒汉式的竞态条件

4.1.2 双检锁模式的正确交互

4.2 单例与依赖组件的交互

在实际应用中，单例对象往往需要与其他系统组件进行交互。以下以日志单例为例展示其与文件系统、网络服务的交互：

5. 总结与最佳实践

5.1 单例模式适用场景总结

单例模式在以下场景中特别有用：

1. 资源共享场景：如数据库连接池、线程池等需要集中管理的资源
2. 配置管理：应用程序的全局配置信息管理
3. 日志记录：统一的日志记录系统
4. 缓存系统：全局缓存管理
5. 设备访问：如打印机后台处理服务

5.2 实现方式选择指南

5.3 最佳实践建议

1. 优先使用Meyer’s Singleton：在C++11及以上环境中，这是最简单安全的实现方式
2. 考虑依赖注入：对于可测试性要求高的项目，考虑使用依赖注入替代单例
3. 谨慎使用单例：单例本质上是全局状态，过度使用会导致代码耦合度高
4. 注意销毁顺序：单例的销毁顺序可能影响其他静态对象的析构
5. 提供重置机制：在测试环境中，提供重置单例状态的方法

5.4 现代C++改进

C++11及以上版本提供了更好的单例实现工具：

• std::call_once：保证一次性初始化
• thread_local：实现线程局部单例
• 原子操作：实现无锁或低锁同步
• 静态局部变量：线程安全的延迟初始化

单例模式是强大的工具，但需要谨慎使用。正确应用时，它可以提供优雅的解决方案；滥用时，它会导致代码难以维护和测试。始终考虑是否真的需要单例，或者是否有更好的替代设计方案。