C++中如何从外部任意时刻暂停并恢复运行中的线程

AI 小北

2026-8-31

首先需要明确一个核心事实：不存在完全无侵入、任意机器指令粒度暂停、且无安全风险的通用C++标准实现。
你期望的“线程外部任意时刻暂停”如果要求完全不修改线程内的业务代码，只能依赖操作系统提供的原生线程挂起API，但这类API会把线程暂停在完全不可控的执行位置，极大概率引发死锁、内存破坏、资源泄漏问题，生产环境几乎不会使用。
工业界实现线程暂停/恢复的通用方案是协作式暂停，实现简单、跨平台、无未定义行为，只要在业务逻辑中插入高频检查点，暂停响应延迟完全可以满足交互需求（人感知不到10ms以内的延迟）。

推荐实现：协作式可暂停线程封装

这个方案的核心逻辑是：自定义Thread类，内置原子暂停标志、互斥锁和条件变量，把暂停检查逻辑封装成轻量回调注入到任务中，用户只需要在耗时任务的步骤间隙（比如每处理一批数据、每渲染一帧、每执行1ms计算后）调用一次检查回调即可，单次检查的开销在纳秒级，几乎无性能损耗。
完整实现代码如下：

#include <thread>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <memory>
#include <iostream>
#include <chrono>

class Thread {
private:
    std::thread worker;
    std::atomic<bool> is_paused{false};
    std::mutex pause_mtx;
    std::condition_variable pause_cv;
    std::function<void(std::function<void()>)> user_task;

    // 内部暂停检查逻辑
    void check_pause() {
        if (is_paused.load(std::memory_order_acquire)) {
            std::unique_lock<std::mutex> lock(pause_mtx);
            pause_cv.wait(lock, [this]() {
                return !is_paused.load(std::memory_order_acquire);
            });
        }
    }

    void run() {
        // 把暂停检查回调传给用户任务
        user_task([this]() { this->check_pause(); });
    }

public:
    Thread(std::function<void(std::function<void()>)> task) 
        : user_task(std::move(task)) {}

    // 启动线程
    void start() {
        if (worker.joinable()) return;
        worker = std::thread(&Thread::run, this);
    }

    // 触发暂停：设置标志后，线程下一次调用pause_point时就会阻塞
    void pause() {
        is_paused.store(true, std::memory_order_release);
    }

    // 恢复线程：清除标志并唤醒阻塞的线程
    void resume() {
        is_paused.store(false, std::memory_order_release);
        pause_cv.notify_one();
    }

    // 等待线程结束
    void join() {
        if (worker.joinable()) {
            // 避免暂停状态下join死锁
            resume();
            worker.join();
        }
    }

    ~Thread() {
        join();
    }
};

对应你需求中的A类调用方式，实现如下：

class A {
private:
    std::unique_ptr<Thread> th;

    // 模拟耗时任务的单步操作
    void do_small_step_work() {
        // 比如处理100条数据、计算1ms的任务、渲染一帧画面
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }

public:
    void foo() {
        th = std::make_unique<Thread>([this](std::function<void()> pause_point) {
            // 持续运行的耗时任务，包含大量执行步骤
            while (true) {
                do_small_step_work();
                // 步骤间隙插入暂停检查点
                pause_point();
            }
        });
        th->start();
    }

    void bar() {
        th->pause();
        std::cout << "The thread is paused now" << std::endl;
    }

    void baz() {
        th->resume();
        std::cout << "The thread is resumed now" << std::endl;
    }
};

这个方案的优势：

完全符合C++标准，跨Windows/Linux/MacOS等所有平台，无未定义行为
暂停位置完全可控，只要你不在持有锁、执行临界区逻辑的位置插入检查点，就不会出现死锁、资源不一致的问题
性能开销极低，只要检查点间隔在10ms以内，用户完全感知不到暂停延迟，完全满足按钮交互的需求

注意事项：不要在持有互斥锁、操作共享资源到一半的临界区中调用pause_point()，否则暂停时会导致其他线程无法获取锁，引发死锁。

非推荐方案：平台API强制任意点暂停（高风险）

如果你完全不想修改线程内的业务代码，要求真正的任意指令位置暂停，只能使用操作系统提供的原生线程挂起API，再次强调：这类方案风险极高，仅适合调试、完全可控的特殊场景，禁止在生产环境使用。
如果线程被挂起时正处于malloc/new内存分配、持有系统锁、执行系统调用的过程中，会直接导致整个进程死锁、内存损坏，问题极难排查。
Windows平台的示例实现：

// 仅Windows平台可用，生产环境禁用
#include <windows.h>

void Thread::pause() {
    HANDLE handle = worker.native_handle();
    SuspendThread(handle);
}

void Thread::resume() {
    HANDLE handle = worker.native_handle();
    ResumeThread(handle);
}

Linux平台没有直接等价的SuspendThread接口，一般通过给目标线程发送专用信号、在信号处理函数中阻塞等待恢复信号的方式实现，同样存在信号安全、死锁风险，不做展开。

内容的提问来源于stack exchange，提问作者Qingguo Hu