[线程类与线程池重构]：切换至 std::jthread 并优化任务队列管理

- **线程类升级**：将原本基于 `std::thread` 的实现切换为使用 C++20 新引入的 `std::jthread`，新增对任务取消和中断的支持，提升线程管理的灵活性与安全性
- **任务队列优化**：新增独立的 `queue.hpp` 文件，实现线程安全的生产者-消费者队列类，支持任务数量限制、动态调整队列大小，并提供更精细的同步控制
- **线程池重构**：基于新的队列类重写了线程池逻辑，简化任务添加流程，优化任务分配机制，提升并发处理效率
- **跨平台适配**：调整 CMake 配置，在 Windows 平台启用线程模块，Linux 平台保留原有网络相关子模块的构建逻辑
- **文档更新**：修改 README 中线程模块的描述，明确指出基于 `std::jthread` 实现，并标注 Apple Clang 编译器暂不支持该特性
- **测试增强**：更新线程和线程池的单元测试用例，增加对任务中断、超时等待等新功能的测试覆盖

Author: RealChuan

CMakeLists.txt

@@ -2,7 +2,6 @@ cmake_minimum_required(VERSION 3.25.1)
 
 include(cmake/vcpkg.cmake)
 
-# 设定工程名
 project(
   Cpp-Examples
   VERSION 0.0.1
@@ -69,12 +68,14 @@ add_subdirectory(MonitorDir_EFSW)
 add_subdirectory(OpenSSL)
 add_subdirectory(SafeCallback)
 add_subdirectory(SpinMutex)
-add_subdirectory(Thread)
 
-if(CMAKE_HOST_LINUX)
+if(CMAKE_HOST_WIN32)
+  add_subdirectory(Thread)
+elseif(CMAKE_HOST_LINUX)
   add_subdirectory(Client)
   add_subdirectory(Icmp)
   add_subdirectory(Server)
+  add_subdirectory(Thread)
 endif()
 
 include(cmake/build_info.cmake)

README.md

@@ -51,6 +51,6 @@
     2. [server_poll](/Server/server_poll.cc)——poll的例子；
     3. [server_select](/Server/server_select.cc)——select的例子；
 23. [SpinMutex](/SpinMutex)——使用std::atomic_flag实现的简单互斥锁和自旋锁；
-24. [Thread](/Thread/)——基于std::thread实现的线程类，包括线程池；
+24. [Thread](/Thread/)——基于std::jthread实现的线程类，包括线程池（`Apple Clang`不支持）；
     1. [Thread](/Thread/thread.hpp)——线程类；
     2. [ThreadPool](/Thread/threadpool.hpp)——线程池；

Thread/CMakeLists.txt

@@ -3,8 +3,8 @@ target_link_libraries(thread_unittest PRIVATE GTest::gtest GTest::gtest_main
                                               GTest::gmock GTest::gmock_main)
 add_test(NAME thread_unittest COMMAND thread_unittest)
 
-add_executable(threadpool_unittest threadpool_unittest.cc threadpool.hpp
-                                   thread.hpp)
+add_executable(threadpool_unittest queue.hpp threadpool_unittest.cc
+                                   threadpool.hpp thread.hpp)
 target_link_libraries(
   threadpool_unittest PRIVATE GTest::gtest GTest::gtest_main GTest::gmock
                               GTest::gmock_main)

Thread/queue.hpp

@@ -0,0 +1,109 @@
+#pragma once
+
+#include <utils/object.hpp>
+
+#include <condition_variable>
+#include <mutex>
+#include <utility>
+#include <queue>
+
+template<typename T>
+    requires std::is_move_assignable_v<T>
+class Queue : noncopyable
+{
+    std::queue<T> m_queue;
+    bool m_stop = false;
+    mutable std::mutex m_mutex;
+    std::condition_variable m_condEmpty;
+    std::condition_variable m_condFull;
+    std::size_t m_maxSize = 0;
+
+public:
+    Queue() = default;
+    explicit Queue(std::size_t maxSize)
+        : m_maxSize(maxSize == 0 ? 1 : maxSize)
+    {}
+    ~Queue() { stop(); }
+
+    [[nodiscard]] auto push(T &&item) -> bool
+    {
+        {
+            std::unique_lock lock(m_mutex);
+            m_condFull.wait(lock, [&]() { return !m_stop && (m_queue.size() < m_maxSize); });
+            if (m_stop) {
+                return false;
+            }
+            m_queue.push(std::move(item));
+        }
+        m_condEmpty.notify_one();
+        return true;
+    }
+
+    [[nodiscard]] auto pop(T &item) -> bool
+    {
+        std::unique_lock lock(m_mutex);
+        m_condEmpty.wait(lock, [&]() { return !m_queue.empty() || m_stop; });
+        if (m_queue.empty()) {
+            return false;
+        }
+        item = std::move(m_queue.front());
+        m_queue.pop();
+        m_condFull.notify_one();
+        return true;
+    }
+
+    void setMaxSize(std::size_t maxSize)
+    {
+        std::scoped_lock guard(m_mutex);
+        m_maxSize = maxSize == 0 ? 1 : maxSize;
+        m_condFull.notify_all();
+    }
+
+    [[nodiscard]] auto getMaxSize() const -> std::size_t
+    {
+        std::scoped_lock guard(m_mutex);
+        return m_maxSize;
+    }
+
+    [[nodiscard]] auto size() const -> std::size_t
+    {
+        std::scoped_lock guard(m_mutex);
+        return m_queue.size();
+    }
+
+    [[nodiscard]] auto empty() const -> bool
+    {
+        std::scoped_lock guard(m_mutex);
+        return m_queue.empty();
+    }
+
+    void clear()
+    {
+        std::scoped_lock guard(m_mutex);
+        std::queue<T>().swap(m_queue);
+        m_condFull.notify_all();
+        m_condEmpty.notify_all();
+    }
+
+    [[nodiscard]] auto isStopped() const -> bool
+    {
+        std::scoped_lock guard(m_mutex);
+        return m_stop;
+    }
+
+    void start()
+    {
+        std::scoped_lock guard(m_mutex);
+        m_stop = false;
+    }
+
+    void stop()
+    {
+        {
+            std::scoped_lock guard(m_mutex);
+            m_stop = true;
+        }
+        m_condEmpty.notify_all();
+        m_condFull.notify_all();
+    }
+};

Thread/thread.hpp

@@ -7,48 +7,83 @@
 #include <chrono>
 #include <condition_variable>
 #include <functional>
+#include <iostream>
 #include <mutex>
 #include <thread>
 
 class Thread : noncopyable
 {
 public:
-    using Task = std::function<void()>;
+    using Task = std::function<void(std::stop_token)>;
 
     Thread() = default;
-    explicit Thread(Task task) { setTask(std::move(task)); }
+
+    explicit Thread(Task task)
+        : m_task(std::move(task))
+    {}
+
     ~Thread() { stop(); }
 
-    void setTask(Task task) { m_task = std::move(task); }
+    void setTask(Task task)
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_task = std::move(task);
+    }
 
-    void start()
+    bool start()
     {
+        if (m_jthread.joinable()) {
+            return false; // Thread is already running
+        }
+
         m_running.store(true);
-        m_thread = std::thread([this]() {
+        m_jthread = std::jthread([this](std::stop_token token) {
             m_condition.notify_one();
             if (m_task) {
-                m_task();
+                try {
+                    m_task(token);
+                } catch (const std::exception &e) {
+                    std::cerr << "Thread exception: " << e.what() << std::endl;
+                }
             }
+
+            m_running.store(false);
         });
+
+        return true; // Thread started successfully
     }
 
     void stop()
     {
-        if (m_thread.joinable()) {
-            m_thread.join();
+        if (m_jthread.joinable()) {
+            m_jthread.request_stop();
+            m_jthread.join();
         }
+
         m_running.store(false);
     }
 
-    void waitForStarted()
+    void interrupt()
+    {
+        if (m_jthread.joinable()) {
+            m_jthread.request_stop();
+            std::cout << "Thread interrupted: " << m_jthread.get_id() << std::endl;
+        }
+    }
+
+    void waitForStarted(std::optional<std::chrono::milliseconds> timeout = std::nullopt)
     {
         std::unique_lock<std::mutex> lock(m_mutex);
-        m_condition.wait(lock, [this]() { return m_running.load(); });
+        if (timeout.has_value()) {
+            m_condition.wait_for(lock, timeout.value(), [this]() { return m_running.load(); });
+        } else {
+            m_condition.wait(lock, [this]() { return m_running.load(); });
+        }
     }
 
-    [[nodiscard]] auto isRunning() const -> bool { return m_running; }
+    [[nodiscard]] bool isRunning() const { return m_running.load(); }
 
-    [[nodiscard]] auto getThreadId() const -> std::thread::id { return m_thread.get_id(); }
+    [[nodiscard]] std::thread::id getThreadId() const { return m_jthread.get_id(); }
 
     static void yield() { std::this_thread::yield(); }
 
@@ -64,13 +99,13 @@ class Thread : noncopyable
 
     static auto hardwareConcurrency() -> unsigned int
     {
-        auto availableCores = std::thread::hardware_concurrency(); // 如果不支持，返回0
+        auto availableCores = std::thread::hardware_concurrency();
         assert(availableCores > 0);
         return availableCores;
     }
 
 private:
-    std::thread m_thread;
+    std::jthread m_jthread;
     std::atomic_bool m_running{false};
     std::mutex m_mutex;
     std::condition_variable m_condition;

Thread/thread_unittest.cc

@@ -2,29 +2,66 @@
 
 #include <gtest/gtest.h>
 
-TEST(Thread, start)
+void testTaskFunction(std::stop_token stopToken)
 {
-    Thread thread([]() { Thread::sleepFor(std::chrono::milliseconds(100)); });
+    for (int i = 0; i < 5; ++i) {
+        if (stopToken.stop_requested()) {
+            break;
+        }
+
+        std::cout << "Test task is running: " << i << std::endl;
+        Thread::sleepFor(std::chrono::milliseconds(200));
+    }
+}
+
+TEST(ThreadTest, StartAndStop)
+{
+    Thread thread;
+    thread.setTask(testTaskFunction);
     thread.start();
     thread.waitForStarted();
-    EXPECT_TRUE(thread.isRunning());
     thread.stop();
     EXPECT_FALSE(thread.isRunning());
 }
 
-TEST(Thread, setTask)
+TEST(ThreadTest, Interrupt)
 {
     Thread thread;
-    thread.setTask([]() { Thread::sleepFor(std::chrono::milliseconds(100)); });
+    thread.setTask(testTaskFunction);
     thread.start();
     thread.waitForStarted();
+    thread.interrupt();
+    Thread::sleepFor(std::chrono::seconds(1));
+    EXPECT_FALSE(thread.isRunning());
+}
+
+TEST(ThreadTest, WaitForStarted)
+{
+    Thread thread;
+    thread.setTask(testTaskFunction);
+    thread.start();
+    thread.waitForStarted(std::chrono::milliseconds(500));
     EXPECT_TRUE(thread.isRunning());
     thread.stop();
-    EXPECT_FALSE(thread.isRunning());
 }
 
-auto main(int argc, char *argv[]) -> int
+TEST(ThreadTest, TaskExecution)
+{
+    Thread thread;
+    bool taskExecuted = false;
+    thread.setTask([&taskExecuted](std::stop_token) {
+        taskExecuted = true;
+        std::cout << "Task executed." << std::endl;
+    });
+    thread.start();
+    thread.waitForStarted();
+    thread.sleepFor(std::chrono::seconds(1));
+    thread.stop();
+    EXPECT_TRUE(taskExecuted);
+}
+
+int main(int argc, char **argv)
 {
-    testing::InitGoogleTest(&argc, argv);
+    ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
 }