C++ std::thread join前提前终止未完成线程的实现方法问询

C++标准没有提供跨平台安全的强制终止线程的方法，因此采用协作式终止+同步通知的方案实现需求，具体步骤如下：

1. 定义共享控制变量 #

首先定义线程安全的共享结构，用于多线程状态同步：

#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <optional>
#include <vector>

// 你原有存储线程数据的结构体
struct ThreadData {
    // 原有业务参数...
    ResultObject result;
};

// 新增共享控制结构
struct SharedControl {
    // 标记是否已经找到有效结果，同时作为线程终止信号
    std::atomic<bool> found_valid = {false};
    // 保护结果写入的互斥锁
    std::mutex result_mtx;
    // 通知主线程结果就绪的条件变量
    std::condition_variable result_cv;
    // 存储首个有效结果
    std::optional<ThreadData> valid_result;
    // 可选：统计已完成线程数，处理所有线程返回无效的场景
    std::atomic<int> finished_count = {0};
};

2. 修改线程处理函数 #

线程执行过程中需要周期性检查终止标记，一旦发现已有有效结果立即终止执行；计算完成后如果结果有效，就写入共享存储并通知主线程：

void process(void* raw_data) {
    // 可将ThreadData和SharedControl打包为一个结构体传入void*，此处示例为拆分传参的写法
    auto* task_data = static_cast<std::pair<ThreadData*, SharedControl*>*>(raw_data);
    ThreadData* tData = task_data->first;
    SharedControl* ctrl = task_data->second;

    // 原有计算逻辑，每执行一段耗时操作就检查一次终止标记
    while(/* 计算未完成 */) {
        if (ctrl->found_valid.load(std::memory_order_acquire)) {
            // 已有有效结果，直接释放资源退出
            delete task_data;
            return;
        }
        // 执行单段耗时不长的计算逻辑，保证终止标记检查频率足够高
    }

    // 计算完成，先累加完成计数
    ctrl->finished_count.fetch_add(1, std::memory_order_release);

    // 判断结果是否有效
    if (/* 你的结果有效判断逻辑，如tData->result不为空 */) {
        std::lock_guard<std::mutex> lk(ctrl->result_mtx);
        // 双重检查避免多个线程同时写入结果
        if (!ctrl->found_valid.load(std::memory_order_acquire)) {
            ctrl->valid_result = *tData;
            ctrl->found_valid.store(true, std::memory_order_release);
            ctrl->result_cv.notify_one(); // 唤醒主线程
        }
    } 
    // 若所有线程都执行完仍无有效结果，也唤醒主线程返回错误
    else if (ctrl->finished_count.load(std::memory_order_acquire) == 线程总数量) {
        ctrl->result_cv.notify_one();
    }

    delete task_data;
    return;
}

3. 修改主线程逻辑 #

主线程不需要逐个等待线程执行完成，而是阻塞在条件变量上等待结果通知，拿到结果后设置终止标记通知所有剩余线程退出，再等待所有线程安全回收后返回结果即可：

int main() {
    const int thread_num = 3;
    SharedControl ctrl;
    std::vector<std::thread> threads;
    std::vector<ThreadData> thread_datas(thread_num);

    // 批量启动线程
    for (int i = 0; i < thread_num; i++) {
        auto* param = new std::pair<ThreadData*, SharedControl*>(&thread_datas[i], &ctrl);
        threads.emplace_back(&process, static_cast<void*>(param));
    }

    // 等待结果通知
    {
        std::unique_lock<std::mutex> lk(ctrl.result_mtx);
        ctrl.result_cv.wait(lk, [&ctrl, thread_num]{ 
            return ctrl.found_valid.load() || ctrl.finished_count.load() == thread_num; 
        });
    }

    // 通知所有未完成的线程终止
    ctrl.found_valid.store(true, std::memory_order_release);

    // 等待所有线程安全退出，此处等待时间极短，因为线程会快速响应终止标记
    for (auto& t : threads) {
        t.join();
    }

    // 返回结果
    if (ctrl.valid_result.has_value()) {
        // 返回有效结果逻辑
        return 0;
    } else {
        // 所有线程返回无效的错误逻辑
        return -1;
    }
}

注意事项 #

• 线程内的终止标记检查频率要足够高，避免剩余线程响应停止请求过慢，若计算逻辑无法拆分，可使用C++20 std::jthread 内置的停止令牌实现更便捷的中断控制。
• 禁止直接调用操作系统API强制终止线程，会导致栈不回滚、锁不释放、资源泄漏等未定义行为。

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