[重构Thread和ThreadPool模块]：改进状态管理和线程安全性

- **Thread类重构**: 将原子状态变量改为互斥锁保护，简化状态管理逻辑，修复竞争条件问题
- **状态转换优化**: 重新设计状态机转换流程，支持在Stopped状态下重新设置任务，提高线程复用性
- **等待机制改进**: 重构waitForFinished方法，支持无限等待和超时等待，修复条件变量使用方式
- **线程池任务类型统一**: 将ThreadPool任务类型统一为Thread::Task，支持stop_token传递，增强任务取消能力
- **线程池关闭逻辑增强**: 改进shutdown和shutdownNow机制，确保任务队列清理和线程安全停止
- **单元测试全面扩展**: 新增大量测试用例，覆盖边界条件、异常处理、性能场景和内存安全性验证
- **停止令牌支持**: 为所有任务添加stop_token参数，实现优雅的任务取消和资源清理机制
- **条件变量使用规范化**: 修复条件变量的等待条件，避免虚假唤醒和竞态条件问题

Author: RealChuan

src/Thread/thread.hpp

@@ -2,11 +2,9 @@
 
 #include <utils/object.hpp>
 
-#include <atomic>
 #include <chrono>
 #include <condition_variable>
 #include <functional>
-#include <future>
 #include <iostream>
 #include <mutex>
 #include <thread>
@@ -17,7 +15,7 @@ class Thread : noncopyable
 public:
     using Task = std::function<void(std::stop_token)>;
 
-    enum class State {
+    enum class State : int {
         Idle,     // 初始状态，未启动
         Starting, // 正在启动
         Running,  // 正在运行
@@ -36,7 +34,7 @@ class Thread : noncopyable
     void setTask(Task task)
     {
         std::lock_guard<std::mutex> lock(m_mutex);
-        if (getStateUnsafe() != State::Idle) {
+        if (m_state != State::Idle && m_state != State::Stopped) {
             throw std::runtime_error("Cannot set task while thread is not idle");
         }
         m_task = std::move(task);
@@ -46,31 +44,17 @@ class Thread : noncopyable
     {
         std::unique_lock<std::mutex> lock(m_mutex);
 
-        // 检查状态
-        if (getStateUnsafe() != State::Idle) {
+        if (m_state != State::Idle || !m_task) {
             return false;
         }
 
-        // 检查任务
-        if (!m_task) {
-            return false;
-        }
-
-        // 设置状态为启动中
-        m_state.store(State::Starting, std::memory_order_release);
+        m_state = State::Starting;
 
         try {
-            // 创建线程
             m_jthread = std::jthread([this](std::stop_token token) { threadMain(token); });
-
-            // 等待线程真正启动 - 修复：使用正确的条件变量等待方式
-            m_condState.wait(lock, [this] {
-                return getStateUnsafe() == State::Running || getStateUnsafe() == State::Stopped;
-            });
-
-            return getStateUnsafe() == State::Running;
+            return true;
         } catch (...) {
-            m_state.store(State::Stopped, std::memory_order_release);
+            m_state = State::Stopped;
             m_condState.notify_all();
             return false;
         }
@@ -87,56 +71,47 @@ class Thread : noncopyable
         }
     }
 
-    bool waitForFinished()
+    bool waitForFinished(std::chrono::milliseconds timeout = std::chrono::milliseconds::max())
     {
         std::unique_lock<std::mutex> lock(m_mutex);
 
-        // 如果已经是停止状态，直接返回
-        if (getStateUnsafe() == State::Stopped) {
-            return true;
-        }
-
-        // 如果还没有启动，也直接返回
-        if (getStateUnsafe() == State::Idle) {
+        // 如果已经是停止状态或空闲状态，直接返回
+        if (m_state == State::Stopped || m_state == State::Idle) {
             return true;
         }
 
-        // 等待状态变为 Stopped - 修复：使用正确的条件变量等待方式
-        m_condState.wait(lock, [this] { return getStateUnsafe() == State::Stopped; });
-
-        return true;
-    }
-
-    bool waitForFinished(std::chrono::milliseconds timeout)
-    {
-        std::unique_lock<std::mutex> lock(m_mutex);
-
-        if (getStateUnsafe() == State::Stopped || getStateUnsafe() == State::Idle) {
+        // 等待状态变为 Stopped
+        if (timeout == std::chrono::milliseconds::max()) {
+            m_condState.wait(lock, [this] { return m_state == State::Stopped; });
             return true;
+        } else {
+            return m_condState.wait_for(lock, timeout, [this] { return m_state == State::Stopped; });
         }
-
-        return m_condState.wait_for(lock, timeout, [this] {
-            return getStateUnsafe() == State::Stopped;
-        });
     }
 
     [[nodiscard]] bool isRunning() const
     {
-        auto state = m_state.load(std::memory_order_acquire);
-        return state == State::Running || state == State::Starting;
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_state == State::Running || m_state == State::Starting;
     }
 
     [[nodiscard]] bool isStopped() const
     {
-        return m_state.load(std::memory_order_acquire) == State::Stopped;
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_state == State::Stopped;
     }
 
     [[nodiscard]] bool isIdle() const
     {
-        return m_state.load(std::memory_order_acquire) == State::Idle;
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_state == State::Idle;
     }
 
-    [[nodiscard]] State getState() const { return m_state.load(std::memory_order_acquire); }
+    [[nodiscard]] State getState() const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_state;
+    }
 
     [[nodiscard]] bool isJoinable() const { return m_jthread.joinable(); }
 
@@ -182,20 +157,10 @@ class Thread : noncopyable
     {
         {
             std::lock_guard<std::mutex> lock(m_mutex);
-
-            // 检查是否在启动过程中被停止
-            if (token.stop_requested()) {
-                m_state.store(State::Stopped, std::memory_order_release);
-                m_condState.notify_all();
-                return;
-            }
-
-            // 标记为运行状态
-            m_state.store(State::Running, std::memory_order_release);
-            m_condState.notify_all();
+            m_state = State::Running;
         }
+        m_condState.notify_all();
 
-        // 执行用户任务
         try {
             if (m_task) {
                 m_task(token);
@@ -206,48 +171,40 @@ class Thread : noncopyable
             std::cerr << "Unknown thread exception" << std::endl;
         }
 
-        // 标记线程结束
         {
             std::lock_guard<std::mutex> lock(m_mutex);
-            m_state.store(State::Stopped, std::memory_order_release);
-            m_condState.notify_all();
+            m_state = State::Stopped;
         }
+        m_condState.notify_all();
     }
 
     void stopInternal(bool useTimeout,
                       std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
     {
-        State currentState = m_state.load(std::memory_order_acquire);
-
-        // 如果已经是停止状态或空闲状态，直接返回
-        if (currentState == State::Stopped || currentState == State::Idle) {
-            return;
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            if (m_state == State::Stopped || m_state == State::Idle) {
+                return;
+            }
         }
 
-        // 请求停止
-        if (m_jthread.joinable()) {
-            m_jthread.request_stop();
-        }
+        requestStop();
 
-        // 等待线程停止
         if (useTimeout) {
             waitForFinished(timeout);
         } else {
             waitForFinished();
         }
 
-        // 如果线程仍然可连接，强制join
         if (!useTimeout && m_jthread.joinable()) {
             m_jthread.join();
         }
     }
 
-    State getStateUnsafe() const { return m_state.load(std::memory_order_relaxed); }
-
 private:
     std::jthread m_jthread;
     mutable std::mutex m_mutex;
     std::condition_variable m_condState;
-    std::atomic<State> m_state{State::Idle};
+    State m_state{State::Idle};
     Task m_task;
 };