不调用std::thread::join()，如何检测std::thread是否已执行完毕？

问题背景 #

11年前（C11时期）已有相关提问，随着C标准迭代，现在有更简洁的方案解决以下痛点：

• std::thread::joinable()存在局限性：即便线程执行完毕，只要未调用join()，它仍会被标记为可join状态，cppreference文档明确说明：

已执行完代码但尚未被join的线程，仍被视为活跃执行线程，因此处于joinable状态。

• 传统方案（如std::atomic<bool>标记线程结束）扩展性差：线程有多个返回点时，需要在每个返回前手动设置标记，代码冗余且容易遗漏。传统示例代码如下：

std::atomic<bool> threadFinished = false;

std::thread myThread([&threadFinished]() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    threadFinished = true;
});

while (true) {
    if (threadFinished) {
        // 线程已执行完毕（注意：myThread.joinable()此时仍为true）
        break;
    }
}

myThread.join();

现代C++优化方案 #

方案1：std::future + std::async（C++11及以后推荐）

std::async自动创建线程并返回std::future对象，通过future.wait_for()可非阻塞检查任务是否完成，无需手动标记状态，多返回点场景下自动处理：

#include <future>
#include <chrono>
#include <thread>

int main() {
    // 强制创建新线程执行异步任务
    auto taskFuture = std::async(std::launch::async, []() {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        
        // 多个返回点无需额外处理
        if (true) {
            return;
        }
        // 其他返回路径
        return;
    });

    // 非阻塞检查任务是否完成
    while (taskFuture.wait_for(std::chrono::seconds(0)) != std::future_status::ready) {
        // 线程未完成时执行的逻辑（如轮询、处理其他任务）
    }

    // 确认任务结束（void返回时get()无实际返回值）
    taskFuture.get();
}

优势：无需手动管理线程生命周期，std::future自动跟踪任务状态，代码简洁不易出错。

方案2：std::packaged_task（适合封装复杂任务，C++11及以后）

若需显式控制线程创建，可用std::packaged_task将任务与std::future绑定，兼顾线程自定义与状态自动跟踪：

#include <future>
#include <chrono>
#include <thread>
#include <functional>

int main() {
    // 封装任务逻辑
    std::packaged_task<void()> task([]() {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        
        if (rand() % 2) {
            return;
        }
        // 另一个返回路径
        return;
    });

    auto taskFuture = task.get_future();
    std::thread workerThread(std::move(task));

    // 非阻塞检查任务状态
    while (taskFuture.wait_for(std::chrono::seconds(0)) != std::future_status::ready) {
        // 等待期间的操作
    }

    workerThread.join();
    taskFuture.get();
}

优势：支持自定义线程属性（如优先级），同时自动管理任务完成状态。

方案3：C++20 std::jthread 结合状态检查

C++20的std::jthread自带自动join机制（析构时自动回收线程），结合std::promise/std::future实现状态跟踪：

#include <future>
#include <chrono>
#include <thread>

int main() {
    std::promise<void> taskPromise;
    auto taskFuture = taskPromise.get_future();

    std::jthread workerThread([promise = std::move(taskPromise)]() mutable {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        // 任务完成时标记状态
        promise.set_value();
    });

    // 非阻塞检查
    while (taskFuture.wait_for(std::chrono::seconds(0)) != std::future_status::ready) {
        // 处理其他逻辑
    }

    // jthread自动join，无需手动调用
}

优势：线程生命周期自动管理，进一步减少手动操作。

总结 #

上述方案均无需手动维护atomic<bool>标记，由标准库自动跟踪任务完成状态，完美解决多返回点场景的扩展性问题，代码更简洁、符合现代C++设计理念。

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