如何创建挂起状态的C++线程？线程暂停与恢复技术咨询

先修正你当前代码的致命问题 #

你当前的addTST函数存在严重错误：局部变量t在函数结束后会被销毁，你把t的指针存入TADE::tsts，后续访问这个指针会触发未定义行为。正确的做法是直接存储std::thread对象，而非指针：

template<typename Func, typename ...Args>
void TADE::addTST(std::string tst_id, Func func, Args ...args) {
    std::thread t(func, std::forward<Args>(args)...);
    // 后续处理
    TADE::tsts.emplace(std::move(tst_id), std::move(t)); // 用移动语义避免拷贝
}

更优方案：延迟启动线程（保存未执行的任务） #

std::thread的设计是构造即启动，无法创建完全未启动的线程对象。更合理的思路是保存任务的函数与参数，直到调用startTST时再创建并启动线程。

实现思路 #

• 定义存储待启动任务的容器，比如std::map<std::string, std::function<void()>>，用lambda或std::bind打包函数和参数。
• addTST仅负责将打包好的任务存入容器。
• startTST取出任务，创建std::thread执行，并将线程存入原有tsts容器。

示例代码 #

class TADE {
private:
    static inline std::map<std::string, std::thread> tsts;
    static inline std::map<std::string, std::function<void()>> pending_tasks; // 待启动任务容器

public:
    template<typename Func, typename ...Args>
    static void addTST(std::string tst_id, Func func, Args ...args) {
        // 打包函数与参数，完美转发避免不必要拷贝
        pending_tasks.emplace(
            std::move(tst_id),
            [func = std::move(func), args = std::make_tuple(std::forward<Args>(args)...)]() mutable {
                std::apply(std::move(func), std::move(args));
            }
        );
    }

    static void startTST(const std::string& tst_id) {
        auto task_it = pending_tasks.find(tst_id);
        if (task_it == pending_tasks.end()) {
            return; // 任务不存在直接返回
        }

        // 创建线程执行任务并存储
        std::thread t(std::move(task_it->second));
        tsts.emplace(tst_id, std::move(t));
        pending_tasks.erase(task_it);
    }
};

手动实现线程的暂停与恢复 #

如果坚持要在创建线程后立即挂起，再手动恢复，可以用std::condition_variable配合标志位实现——这是C++标准库中安全的线程同步方式，避免系统级 suspend 接口的死锁风险。

实现思路 #

• 给每个线程绑定控制结构体，包含暂停标志位、互斥量和条件变量。
• 线程启动后进入等待状态（挂起），直到调用resumeTST时唤醒。
• 可扩展支持任务执行中途的暂停/恢复循环。

示例代码 #

#include <thread>
#include <map>
#include <condition_variable>
#include <mutex>
#include <functional>
#include <tuple>

class TADE {
private:
    // 线程控制结构体，存储同步原语与状态标志
    struct ThreadControl {
        std::thread t;
        std::mutex mtx;
        std::condition_variable cv;
        bool is_paused = true; // 初始状态设为暂停
        bool should_exit = false; // 线程退出标志
    };

    static inline std::map<std::string, ThreadControl> tsts;

    // 任务包装函数，添加暂停/恢复逻辑
    template<typename Func>
    static void task_wrapper(Func func, ThreadControl* ctrl) {
        std::unique_lock<std::mutex> lock(ctrl->mtx);
        // 初始等待，直到被唤醒或收到退出指令
        ctrl->cv.wait(lock, [ctrl](){ return !ctrl->is_paused || ctrl->should_exit; });

        if (!ctrl->should_exit) {
            func(); // 执行实际任务
        }

        // 若需支持中途暂停，可在任务逻辑中插入等待逻辑：
        // while (!ctrl->should_exit) {
        //     // 执行一段任务逻辑
        //     ctrl->cv.wait(lock, [ctrl](){ return !ctrl->is_paused || ctrl->should_exit; });
        // }
    }

public:
    template<typename Func, typename ...Args>
    static void addTST(std::string tst_id, Func func, Args ...args) {
        // 绑定参数生成可调用对象
        auto task = std::bind(std::forward<Func>(func), std::forward<Args>(args)...);

        ThreadControl ctrl;
        // 创建线程执行包装后的任务
        ctrl.t = std::thread(task_wrapper<decltype(task)>, std::move(task), &ctrl);
        tsts.emplace(std::move(tst_id), std::move(ctrl));
    }

    static void resumeTST(const std::string& tst_id) {
        auto it = tsts.find(tst_id);
        if (it == tsts.end()) {
            return;
        }

        std::lock_guard<std::mutex> lock(it->second.mtx);
        it->second.is_paused = false;
        it->second.cv.notify_one();
    }

    static void pauseTST(const std::string& tst_id) {
        auto it = tsts.find(tst_id);
        if (it == tsts.end()) {
            return;
        }

        std::lock_guard<std::mutex> lock(it->second.mtx);
        it->second.is_paused = true;
    }

    // 安全退出线程并清理资源
    static void stopTST(const std::string& tst_id) {
        auto it = tsts.find(tst_id);
        if (it == tsts.end()) {
            return;
        }

        {
            std::lock_guard<std::mutex> lock(it->second.mtx);
            it->second.should_exit = true;
            it->second.is_paused = false;
            it->second.cv.notify_one();
        }

        if (it->second.t.joinable()) {
            it->second.t.join();
        }
        tsts.erase(it);
    }
};

关键注意事项 #

• 禁止使用系统级接口如Windows的SuspendThread或POSIX的pthread_suspend：线程可能在持有锁的状态下被挂起，直接导致死锁，属于未定义行为。
• 条件变量的wait必须配合谓词，避免虚假唤醒。
• 所有操作控制结构体的代码必须加锁，保证线程安全。

内容的提问来源于stack exchange，提问作者Yasin Sahin