[新增Singleton模块]: 添加现代化线程安全的单例模式实现

-**新增**: 添加Singleton模块，包含模板化的单例基类，使用C++11特性确保线程安全
-**新增**: 实现SINGLETON宏，简化单例类的定义，自动处理拷贝和移动操作的禁用
-**新增**: 提供完整的单元测试，验证单例的唯一性、线程安全性、功能正确性等特性
-**更新**: 在项目README中新增Singleton模块说明，更新代码结构目录
-**更新**: 在根CMakeLists.txt中添加Singleton子目录，集成到项目构建系统中
-**修改**: 调整Thread模块单元测试，将空任务改为短暂睡眠以避免线程立即停止

Author: RealChuan

README.md

@@ -7,7 +7,7 @@
 
 ## 项目概述
 
-这个项目收集了各种 C++ 编程中的实用示例，涵盖了系统编程、加密算法、多线程、崩溃处理等多个领域。每个示例都力求简洁明了，便于学习和在实际项目中使用。
+这个项目收集了各种 C++ 编程中的实用示例，涵盖了系统编程、加密算法、多线程、崩溃处理、设计模式等多个领域。每个示例都力求简洁明了，便于学习和在实际项目中使用。
 
 ## 代码结构
 
@@ -71,7 +71,14 @@ OpenSSL 加密算法使用示例。
 - `openssl_hash.cc` - SHA256 哈希计算示例
 - `openssl_rsa.cc` - RSA 加解密示例
 
-### 8. [Thread](src/Thread/)
+### 8. [Singleton](src/Singleton/)
+
+现代化线程安全的单例模式实现，使用 C++11 特性确保跨平台兼容性。
+
+- `singleton.hpp` - 模板化的单例基类，提供线程安全的实例访问
+- `singleton_unitest.cc` - 完整的单元测试，验证单例的唯一性、线程安全性等特性
+
+### 9. [Thread](src/Thread/)
 
 基于 std::jthread 实现的线程和线程池（注意：Apple Clang 不支持）。
 
@@ -80,7 +87,7 @@ OpenSSL 加密算法使用示例。
 - `queue.hpp` - 线程安全队列
 - `*_unittest.cc` - 各组件单元测试
 
-### 9. [utils](src/utils/)
+### 10. [utils](src/utils/)
 
 通用工具类。
 

src/CMakeLists.txt

@@ -4,6 +4,7 @@ add_subdirectory(Crashpad)
 add_subdirectory(Memcpy)
 add_subdirectory(MonitorDir)
 add_subdirectory(MonitorDir_EFSW)
+add_subdirectory(Singleton)
 add_subdirectory(OpenSSL)
 
 if(CMAKE_HOST_WIN32)

src/Singleton/CMakeLists.txt

@@ -0,0 +1,4 @@
+add_executable(singleton_unitest singleton_unitest.cc singleton.hpp)
+target_link_libraries(singleton_unitest PRIVATE GTest::gtest GTest::gtest_main
+                                                GTest::gmock GTest::gmock_main)
+add_test(NAME singleton_unitest COMMAND singleton_unitest)

src/Singleton/singleton.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <utils/object.hpp>
+
+template<typename T>
+class Singleton
+{
+    DISABLE_COPY_MOVE(Singleton)
+public:
+    static T &instance()
+    {
+        static T instance;
+        return instance;
+    }
+
+    static T *getInstance() { return &instance(); }
+
+protected:
+    Singleton() = default;
+    virtual ~Singleton() = default;
+};
+
+#define SINGLETON(Class) \
+private: \
+    Class(const Class &) = delete; \
+    Class &operator=(const Class &) = delete; \
+    Class(Class &&) = delete; \
+    Class &operator=(Class &&) = delete; \
+    friend class Singleton<Class>; \
+\
+protected: \
+    Class() = default; \
+\
+public: \
+    static Class &instance() \
+    { \
+        return Singleton<Class>::instance(); \
+    }\

src/Singleton/singleton_unitest.cc

@@ -0,0 +1,242 @@
+#include "singleton.hpp"
+
+#include <gtest/gtest.h>
+
+#include <atomic>
+#include <chrono>
+#include <future>
+#include <string>
+#include <thread>
+#include <vector>
+
+// 测试用的单例类
+class TestSingleton : public Singleton<TestSingleton>
+{
+    friend class Singleton<TestSingleton>;
+
+private:
+    TestSingleton()
+        : value(0)
+    {}
+
+public:
+    void setValue(int val) { value = val; }
+    int getValue() const { return value; }
+    void increment() { ++value; }
+
+private:
+    std::atomic<int> value;
+};
+
+// 另一个测试用的单例类
+class AnotherSingleton
+{
+    SINGLETON(AnotherSingleton)
+
+public:
+    std::string getName() const { return "AnotherSingleton"; }
+    void setData(const std::string &data) { m_data = data; } // 重命名避免冲突
+    std::string getData() const { return m_data; }
+
+private:
+    std::string m_data; // 重命名避免警告
+};
+
+// 基础功能测试
+class SingletonTest : public ::testing::Test
+{
+protected:
+    void SetUp() override
+    {
+        // 每个测试前重置单例状态（如果需要的话）
+    }
+
+    void TearDown() override
+    {
+        // 清理工作
+    }
+};
+
+// 测试单例实例的唯一性
+TEST_F(SingletonTest, InstanceUniqueness)
+{
+    TestSingleton &instance1 = TestSingleton::instance();
+    TestSingleton &instance2 = TestSingleton::instance();
+    TestSingleton *instance3 = TestSingleton::getInstance();
+
+    // 验证所有获取方式返回的是同一个实例
+    EXPECT_EQ(&instance1, &instance2);
+    EXPECT_EQ(&instance1, instance3);
+    EXPECT_EQ(&instance2, instance3);
+}
+
+// 测试单例的功能方法
+TEST_F(SingletonTest, Functionality)
+{
+    TestSingleton &instance = TestSingleton::instance();
+
+    // 测试设置和获取值
+    instance.setValue(42);
+    EXPECT_EQ(instance.getValue(), 42);
+
+    // 测试修改值
+    instance.increment();
+    EXPECT_EQ(instance.getValue(), 43);
+}
+
+// 测试多个单例类的独立性
+TEST_F(SingletonTest, MultipleSingletonIndependence)
+{
+    TestSingleton &testInstance = TestSingleton::instance();
+    AnotherSingleton &anotherInstance = AnotherSingleton::instance();
+
+    testInstance.setValue(100);
+    anotherInstance.setData("test_data");
+
+    // 验证两个单例实例不冲突
+    EXPECT_EQ(testInstance.getValue(), 100);
+    EXPECT_EQ(anotherInstance.getData(), "test_data");
+    EXPECT_NE(reinterpret_cast<void *>(&testInstance), reinterpret_cast<void *>(&anotherInstance));
+}
+
+// 测试单例的不可拷贝和不可移动特性
+TEST_F(SingletonTest, NonCopyableNonMovable)
+{
+    // 这些代码应该编译失败，我们通过SFINAE或编译时检查来验证
+    // 在实际测试中，我们可以验证这些特性是否存在
+
+    EXPECT_TRUE(std::is_copy_constructible_v<TestSingleton> == false);
+    EXPECT_TRUE(std::is_copy_assignable_v<TestSingleton> == false);
+    EXPECT_TRUE(std::is_move_constructible_v<TestSingleton> == false);
+    EXPECT_TRUE(std::is_move_assignable_v<TestSingleton> == false);
+}
+
+// 辅助函数用于多线程测试
+void threadTask(int threadId, std::promise<TestSingleton *> &promise)
+{
+    (void) threadId; // 标记未使用参数，消除警告
+    TestSingleton &instance = TestSingleton::instance();
+    instance.increment(); // 每个线程增加一次
+    promise.set_value(&instance);
+}
+
+// 多线程安全性测试
+TEST_F(SingletonTest, ThreadSafety)
+{
+    constexpr int numThreads = 10;
+
+    // 创建一个新的单例类用于线程测试
+    class ThreadTestSingleton : public Singleton<ThreadTestSingleton>
+    {
+        friend class Singleton<ThreadTestSingleton>;
+
+    private:
+        ThreadTestSingleton()
+            : counter(0)
+        {}
+
+    public:
+        void increment() { ++counter; }
+        int getCounter() const { return counter; }
+
+    private:
+        std::atomic<int> counter;
+    };
+
+    // 启动多个线程同时访问单例
+    std::vector<std::thread> testThreads;
+    std::vector<std::future<ThreadTestSingleton *>> testFutures;
+    std::vector<std::promise<ThreadTestSingleton *>> testPromises(numThreads);
+
+    for (auto &promise : testPromises) {
+        testFutures.push_back(promise.get_future());
+    }
+
+    for (int i = 0; i < numThreads; ++i) {
+        testThreads.emplace_back([i, &testPromises]() {
+            ThreadTestSingleton &instance = ThreadTestSingleton::instance();
+            instance.increment();
+            testPromises[i].set_value(&instance);
+        });
+    }
+
+    // 等待所有线程完成
+    for (auto &thread : testThreads) {
+        thread.join();
+    }
+
+    // 验证所有线程获取的是同一个实例
+    ThreadTestSingleton *firstInstance = testFutures[0].get();
+    for (size_t i = 1; i < testFutures.size(); ++i) {
+        EXPECT_EQ(firstInstance, testFutures[i].get());
+    }
+
+    // 验证计数器值正确（每个线程增加了一次）
+    EXPECT_EQ(firstInstance->getCounter(), numThreads);
+}
+
+// 测试单例的继承特性
+class DerivedSingleton : public Singleton<DerivedSingleton>
+{
+    friend class Singleton<DerivedSingleton>;
+
+private:
+    DerivedSingleton()
+        : specialValue(999)
+    {}
+
+public:
+    int getSpecialValue() const { return specialValue; }
+    virtual std::string getType() { return "DerivedSingleton"; }
+
+private:
+    int specialValue;
+};
+
+TEST_F(SingletonTest, Inheritance)
+{
+    DerivedSingleton &instance = DerivedSingleton::instance();
+    EXPECT_EQ(instance.getSpecialValue(), 999);
+    EXPECT_EQ(instance.getType(), "DerivedSingleton");
+}
+
+// 性能测试（可选）
+TEST_F(SingletonTest, Performance)
+{
+    auto start = std::chrono::high_resolution_clock::now(); // 修正后的代码
+
+    constexpr int iterations = 100000;
+    for (int i = 0; i < iterations; ++i) {
+        TestSingleton &instance = TestSingleton::instance();
+        (void) instance; // 避免未使用变量警告
+    }
+
+    auto end = std::chrono::high_resolution_clock::now(); // 修正后的代码
+    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+
+    // 验证获取实例的时间在合理范围内
+    // 这个阈值可能需要根据具体环境调整
+    EXPECT_LT(duration.count(), 1000000); // 小于1秒
+}
+
+// 测试单例宏的正确性
+TEST_F(SingletonTest, MacroUsage)
+{
+    // 验证使用宏的单例类具有正确的特性
+    EXPECT_FALSE(std::is_default_constructible_v<AnotherSingleton>);
+    EXPECT_FALSE(std::is_copy_constructible_v<AnotherSingleton>);
+    EXPECT_FALSE(std::is_copy_assignable_v<AnotherSingleton>);
+    EXPECT_FALSE(std::is_move_constructible_v<AnotherSingleton>);
+    EXPECT_FALSE(std::is_move_assignable_v<AnotherSingleton>);
+
+    // 验证实例方法存在且工作正常
+    AnotherSingleton &instance = AnotherSingleton::instance();
+    EXPECT_EQ(instance.getName(), "AnotherSingleton");
+}
+
+// 主函数
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

src/Thread/thread_unittest.cc

@@ -372,11 +372,10 @@ TEST_F(ThreadTest, RapidStartStop)
     std::vector<std::unique_ptr<Thread>> threads;
 
     for (int i = 0; i < NUM_THREADS; ++i) {
-        auto thread = std::make_unique<Thread>([](std::stop_token token) {
-            // 空任务，立即返回
-        });
+        auto thread = std::make_unique<Thread>(
+            [](std::stop_token token) { std::this_thread::sleep_for(10ms); });
 
-        EXPECT_FALSE(thread->start()); // 线程状态很快变为Stopped
+        EXPECT_TRUE(thread->start());
         threads.push_back(std::move(thread));
     }