C++一文讲透thread中的detach和join的差别

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

无论哪种语言线程在绝大多数项目中都是会用到的，C++也一样，C++包装了一个std::thread类可以简化程序员的编程，但在使用过程中也要注意区分用法，否则可能适得其反。

今天要讨论的就是单纯的thread的join（等待）和detach（分离）两种情景，让不懂得人看完之后茅塞顿开。

---

一、thread详解

C++标准库成员，是对线程的包装类，在thread头文件里面，使用方式是std::thread。创建线程本身就是通过创建一个thread类对象然后和系统线程完成绑定（映射），这样可以通过操作thread类对象来管理创建的系统线程，系统线程本身行为受到内核调度机制影响。

示例代码：

#include <iostream>
#include <thread>

// 线程函数
void threadFunction() {
    std::cout << "Thread function is running" << std::endl;
}

int main() {
    // 创建线程并启动
    std::thread t(threadFunction);

    // 等待线程完成
    t.join();

    std::cout << "Main thread is running" << std::endl;
    return 0;
}

注意：这个地方如果不使用t.join()可能导致main线程早于子线程结束，引发terminate！

二、线程何时运行

这个问题一定要说清楚才行，我以前用java的时候线程有一个start()可以决定什么时候启动线程，C++则不是这样，C++没有一个明确方法决定线程何时运行，只需要满足创建并等待（一般时间很短，取决于实际情况），直到线程获取了资源之后就会自动运行，而不需要显式调用方法。且无论是以join还是detach方式启动的线程都受到内核的调度。

三、线程启动方式

1.join

主线程（创建子线程的那个线程）等待子线程执行完毕才进行下一步，适合那种需要立刻得到结果的场景。创建方式很简单，你只需要先创建线程然后在合适的时候调用t.join()等待结束即可。

示例代码：

#include <iostream>
#include <thread>

int main() {
    std::thread t([]{
        std::cout << "Lambda function is running" << std::endl;
    });

    t.join();

    std::cout << "Main thread is running" << std::endl;
    return 0;
}

当调用t.join()方法时主线程的等待，直到t线程结束主线程才会继续运行，程序结束。如果子线程里面有死锁主线程就会一直等待，永无休止。

2.detach

在C++中，std::thread提供了一个detach方法，可以将线程从其控制对象中分离。分离的线程会在后台独立运行，直到完成。此方法常用于不需要同步或获取线程结果的情况。不过，在使用detach时需要小心，因为主线程不能再控制或管理该分离的线程，这可能会导致资源管理和程序结束时的问题。

另外，detach之后的变量不能重新join。

示例代码：

#include <iostream>
#include <thread>
#include <chrono>

void worker() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "Worker thread finished\n";
}

int main() {
    std::thread t(worker);

    // 分离线程
    t.detach();

    std::cout << "Main thread finished\n";
    // 此处主线程可能已经结束，而分离的线程仍在运行
    std::this_thread::sleep_for(std::chrono::seconds(3));  // 确保主线程不会立即退出
    return 0;
}

创建的子线程很快就会结束，所以主线程3秒的休眠足够了，如果子线程超过3秒就会导致主线程早于子线程结束，程序terminate。

terminate called without an active exception

Process finished with exit code 3

所以，还是要面对一个问题，detach后的线程怎么管理？我并不能时时刻刻知道线程的状态，如果主线程结束了子线程没结束怎么办？方法还是有的，那就是增加标志位（同步需要atomic或锁），如果我想一个线程结束只需要修改标志位。比如下面的代码：

#include <iostream>
#include <thread>
#include <atomic>
#include <chrono>

std::atomic<bool> keepRunning(true); // 原子布尔变量，用于控制线程执行

void threadFunction() {
    while (keepRunning) {
        std::cout << "Thread is running..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    std::cout << "Thread stopped." << std::endl;
}

int main() {
    std::thread t(threadFunction);

    // 主线程等待一段时间后停止子线程
    std::this_thread::sleep_for(std::chrono::seconds(5));
    keepRunning = false; // 设置标志位，通知线程停止

    t.join(); // 等待线程结束

    std::cout << "Main thread is running" << std::endl;
    return 0;
}

还可以借助boost库的方法来打断线程。例如：

#include <iostream>
#include <boost/thread.hpp>

void threadFunction() {
    try {
        while (true) {
            // 执行一些工作
            boost::this_thread::interruption_point();
        }
    } catch (boost::thread_interrupted&) {
        std::cout << "Thread interrupted." << std::endl;
    }
}

int main() {
    boost::thread t(threadFunction);

    // 主线程等待一段时间后中断子线程
    boost::this_thread::sleep_for(boost::chrono::seconds(5));
    t.interrupt(); // 中断线程

    t.join(); // 等待线程结束

    std::cout << "Main thread is running" << std::endl;
    return 0;
}

切记，不要随意中断线程，防止资源泄露！不管是标志位、条件判断还是boost库都必须考虑资源回收的问题，否则如果子线程里面使用了自由存储将永远无法得到回收。

---

总结

不管哪种方式启动的线程都要保证资源的回收，特别是当心主线程早于子线程结束的情况。还有一种容易让人疏忽的情况：如果你在一个函数里创建了thread对象，你没有join或detach，如果在函数return前线程没被回收就会导致terminate。比如，下面的代码：

void test(){
}

void thread_join_detach(){
    std::thread t(test);
//    t.detach();
//    t.join();
}

int main() {
    thread_join_detach();
    return 0;
}

上面的代码thread_join_detach函数返回会回收t对象，如果线程t还没结束就会terminate。解决方法有很多，比较简单的就是在函数return之前调用join或detach，还有就是把t提升作用域，比如全局变量。