多线程/std::thread线程退出方式详解

概述

这里默认你已经了解 std::thread 类的基本使用，和WinAPI多线程编程中 “如何优雅的退出线程” 等相关知识。阅读该文前，建议先看看《多线程 /C++ 11 std::thread 类深入理解和应用实践》 和 《多线程/WinAPI线程退出方式比较分析》这两篇文章。在 函数 join 和 函数 detach 的帮助文档中都讲到，
join(), After a call to this function, the thread object becomes non-joinable and can be destroyed safely.
detach(), After a call to std::thread::detach, the thread object becomes non-joinable and can be destroyed safely.
即在线程对象上调用 join函数或detach函数 后，线程对象便可安全地销毁了，何为安全，真的安全吗？

另外一个问题是，std::thread并未提供，像ExitThread、TerminateThread这样的终止线程的接口，也没有直接提供WaitForSingleObject 类似的等待函数， 当使用 std::thread 进行多线程编程时，似乎只有 “入口函数返回” 这一种方式。另外就是进程退出倒逼线程退出的方式。

不 join 也不 detach

int main()
{
    int interval_child = 1, interval_main = 2;  //s
    //
    std::thread t1 = std::thread([&]() {
        std::this_thread::sleep_for(std::chrono::seconds(interval_child));
        printf("at:%f, t1_entry_func return \n", DalOsTimeSysGetTime());
    });

    //预留时间，等待次线程结束
    std::this_thread::sleep_for(std::chrono::seconds(interval_main));
    //
    printf("at:%f, main end sleep t1.joinable:%d \n", DalOsTimeSysGetTime(), t1.joinable());

    //try {
    //    t1.join();
    //    printf("at:%f, t1.join return \n", DalOsTimeSysGetTime());
    //}
    //catch (const std::exception&) {
    //    std::cout << "any system_error exception \n";
    //}

    //system("pause");  
    
    return 0;
}

上述代码，运行结果如下：

可以得出，
1、即使线程对象代表的执行线程已经（函数返回）完成，此时对象 t1 依然是 joinable，可加入到其他线程中的。
2、进程退出前，如果没有对 std::thread 对象 t1 执行 join 或 detach 操作，则会触发abort终止进程。
补充，
一般情况下，无法通过异常处理机制捕获导致abort()调用的异常。当调用abort()函数时，理论上，可以通过一些系统相关的底层注册机制拦截或过滤它，我尝试了几种方式都没有成功，这里不再深究。

执行了detach并不能万事大吉

改动detach帮助下的示例程序如下，主要目的在于测试：进程退出后，子线程是否会 继续 完成执行过程。

#include <iostream>       // std::cout
#include <thread>         // std::thread, std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds
#include <string.h>
#include <fstream>
#include <stdio.h>
#include <windows.h>

using namespace std;

//辅助函数 //写log函数
void WriteLog(const char * format, ...)
{
    char buff[128] = { 0 };
    va_list ap;
    va_start(ap, format);
    vsprintf_s(buff, 128, format, ap);
    va_end(ap);
    //
    std::ofstream outfile("result.txt", std::ios_base::app);
    outfile.write(buff, strlen(buff));
    outfile.close();
}

//辅助函数 //时刻值ms //%f
double DalOsTimeSysGetTime(void)
{
    LARGE_INTEGER nFreq; LARGE_INTEGER nBeginTime;
    QueryPerformanceFrequency(&nFreq);
    QueryPerformanceCounter(&nBeginTime);
    return (double)(nBeginTime.QuadPart * 1000 / (double)nFreq.QuadPart);
}

//定义一个C++类对象
class ClassA
{
public:
    ClassA(int id): m_id(id) {
        WriteLog("CppObject-%d 构造 at %f\n", m_id, DalOsTimeSysGetTime());
        //申请堆内存
        m_pData = new TData();
    }
    ~ClassA() {
        WriteLog("CppObject-%d 析构 at %f\n", m_id, DalOsTimeSysGetTime());
        //释放堆内存
        if (NULL != m_pData) {
            delete m_pData;
            m_pData = NULL;
        }
    }

private:
    struct TData { //数据类
        int a;  int b;
    };

    TData *m_pData = NULL; int m_id = 0;
};

//入口函数
void pause_thread(int n)
{
    //定义在线程栈上的对象
    ClassA aObjectInStack(n);
    //使得指定的次线程睡眠n秒
    std::this_thread::sleep_for(std::chrono::seconds(n));
    //
    WriteLog("thread_%d pause %d seconds, then return at %f \n", n, n, DalOsTimeSysGetTime());
}

int main()
{
    std::ofstream outfile("result.txt", std::ios_base::trunc);
    outfile.close(); //清空日志文件

    std::cout << "Spawning and detaching 3 threads...\n";
    std::thread(pause_thread, 1).detach();
    std::thread(pause_thread, 2).detach();
    std::thread(pause_thread, 4).detach();
    std::cout << "Done spawning threads.\n";

    std::cout << "the main thread will now pause for 3 seconds\n";
    //you can give the detached threads time to finish (but not guaranteed!):
    std::this_thread::sleep_for(std::chrono::seconds(3));

    return 0;
}

//CppObject - 1 构造 at 112975428.942300
//CppObject - 2 构造 at 112975430.304200
//CppObject - 4 构造 at 112975431.947500
//thread_1 pause 1 seconds, then return at 112976440.094500
//CppObject - 1 析构 at 112976441.718200
//thread_2 pause 2 seconds, then return at 112977441.448000
//CppObject - 2 析构 at 112977442.140000
//id==4的线程 入口函数未完成执行，其内的对象未触发析构。

可以看出来，在进程退出后，
1、正在运行的线程入口函数的执行是"戛然而止"的，如果此时pause_thread入口函数内是while循环模式的，则线程将极有可能要死在while单次循环执行过程中，这是危险不优雅的。
2、入口函数若没有执行返回，则不会触发线程函数内对象的析构过程。
3、在 detach 作用下，并不会保证入口函数返回。 进程退出时，如果入口函数已经完成，则没有任何问题。但如果此时入口函数尚在执行过程中（如等待、耗时IO操作等），将与windowsAPI::ExitThread 的使用效果如出一辙。故，在使用detach分离线程后，若不加以控制使得入口函数能保证是可返回的，虽然系统会释放线程栈，但是由于此时析构过程未触发，依然存在m_pData堆内存泄漏的问题。

进程退出，
只要进程不退出（如将主线程使用system(“pause”) 或者 使用while循环睡眠，来保持运行），则detach的次线程便可以一直运行下去（如果它能一直运行下去），这是毋庸置疑的。如果宿主线程（或称MSDN中的calling thread调用线程）不是主线程，而是其他次线程，则线程对象在被detach后更不会退出执行。

建议使用 join 函数

讨论来讨论去，还是建议使用 join函数老实的等待执行线程退出。为此，我们可能需要将线程对象创建为成员变量或全局变量，以能在线程停止函数中调用join函数，实现等待操作。如下：

//在stop函数中利用join等待
void MyThreadStop() {
	m_runningFlag = fale;
	join();
}

平日里我们见到的示例程序大都简单到只是在main函数中创建子线程并直接退出，在main函数中 “同步地” 调用detach或join就完犊了。而实际使用中通常会更 “异步” 一些。如，在Qt环境的事件循环机制下，join的 “异步” 调用可能是：

#mian.cpp

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MianWnd w;
    w.show();
    return a.exec();
}

#mianWnd.h

class MianWnd : public QMainWindow
{
    Q_OBJECT
public:
    MianWnd(QWidget *parent = Q_NULLPTR);
    ~MianWnd();
private:
    //函数入口
    void pause_thread(int n);
    //停止函数
    void MyThreadStop();
private:
    //线程
    std::thread m_thread;
    //运行标志
    bool m_runningFlag = true;
    //堆栈资源
    struct TStruct
    { int a; int b; } *m_pResource;
private:
    Ui::MianWndClass ui;
};

#mainWnd.cpp

//辅助函数 //时刻值ms 
double DalOsTimeSysGetTime(void)
{
    LARGE_INTEGER nFreq; LARGE_INTEGER nBeginTime;

    QueryPerformanceFrequency(&nFreq);
    QueryPerformanceCounter(&nBeginTime);

    return (double)(nBeginTime.QuadPart * 1000 / (double)nFreq.QuadPart);
}

//辅助函数
void TraceForVStudio(char *fmt, ...)
{
    char out[1024] = { 0 };
    va_list body;
    va_start(body, fmt);
    vsprintf_s(out, 1024, fmt, body);
    va_end(body);    
    OutputDebugStringA(out); 
    OutputDebugStringA("\r\n");
}
//入口函数
void MianWnd::pause_thread(int n)
{
    while (m_runningFlag) //
    {
        if (NULL != m_pResource) //子线程内使用(共享)资源
            TraceForVStudio("Using Resource# a:%d b:%d ", ++m_pResource->a, ++m_pResource->b);

        std::this_thread::sleep_for(std::chrono::seconds(n));
    }
    //may do something other..
}
//停止函数
void MianWnd::MyThreadStop()
{
    m_runningFlag = false;
    m_thread.join();  //block
}
//构造函数
MianWnd::MianWnd(QWidget *parent)
    : QMainWindow(parent)
{
    ui.setupUi(this);
	//资源
    m_pResource = new TStruct();
    //线程
    m_thread = std::thread(&MianWnd::pause_thread, this, 5);
}
//析构函数
MianWnd::~MianWnd()
{
    //停止线程
    TraceForVStudio("Wait Begin At:%f", DalOsTimeSysGetTime()) ;
    MyThreadStop();
    TraceForVStudio("Wait Finish At:%f", DalOsTimeSysGetTime()); 
    //销毁线程资源
    if (NULL != m_pResource)
    { delete m_pResource; m_pResource = nullptr; }
    //销毁UI及其子窗口对象..
}

//关闭窗口触发析构过程
//Using Resource# a:1 b:1
//Using Resource# a:2 b:2
//...
//Wait Begin  At : 93813551.843300
//Exit Thread At : 93816981.917300 //about 3.5s
//Wait Finish At : 93816988.057200 //about 007ms

通过上述测试，可以确定join函数可以起到很好的等待线程退出的效果，比std::condition_variable 方便的多。上述，每5s完成单次循环，我随机关闭窗口触发析构过程，m_runningFlag 置零后大约过了3.5s后生效，然后入口函数退出，又过了7ms左右，join函数从阻塞过程中返回，析构过程继续执行堆栈资源的销毁过程。