Effective Modern C++ Item 37：确保std::thread在销毁时是unjoinable的

下面这段代码，如果调用func，按照C++的标准，程序会被终止（std::terminate）

void func()
{
    std::thread t([]
    {
        std::chrono::microseconds dua();
        std::this_thread::sleep_for(dua);
    });
}

原因在于C++标准规定，std::thread的析构被调用时，std::thread必须是unjoinable的，否则std::terminate就会被调用。

std::thread有两种状态，joinable和unjoinable，unjoinable的std::thread包括：

• 使用默认构造的std::thread。这种std::thread没有任何执行任务。
• 被移动的std::thread。比如std::thread t2(std::move(t1))，这时t1的执行工作就转移给了t2，t1变成了unjoinable的状态。
• 已经被join的std::thread。调用了join之后，std::thread就变成了unjoinable的状态。
• 已经被detach的std::thread。detach会断开std::thread和执行任务之间的连接。

之前的func中创建的thread，在销毁时是属于joinable状态的（不是默认构造，没有被移动，没有join和detach，并且线程还在运行），所以按照C++的标准，程序会被强行终止。

为什么C++要采用这种暴力的方式？因为如果采用别的方式，都会导致相应的问题。

我们假设C++标准采用其他的方式，分别分析会有什么问题：

1. 在std::thread的析构里显式调用join。这种方式会导致潜在的性能问题，因为join是阻塞调用，那么意味着thread的析构就可能会阻塞，某些情况下并不希望thread join，而是满足一定的条件才join，比如下面这种代码：

void doSomething()
{
    std::thread t(doWork());
    if(someCondition())
    {
        t.join();
        getResult();
    }
}

代码的本意是在condition满足时才会join线程，不满足就直接返回。因为std::thread的析构里会显式join，那么即使condition不满足，在函数退出时也会join。如果doWork是耗时的步骤，那么不管condition满不满足，doSomething都会阻塞直到doWork完成。

2. 在std::thread的析构里显式调用detach。这种方式看上去不会有第一种方式的性能问题，其实更糟糕，可能会导致runtime error。比如下面这种代码：

void doSomething()
{
    std::vector<int> data;
    std::thread t([&data]
    {
        for (int i = ; i <= ; ++i)
            data.push_back(i);
    });
}

当函数退出时，std::thread调用detach，那么线程的执行任务还在继续，函数栈的临时变量已被销毁，程序就会出现undefined行为，而且调试起来也很困难。detach本身就容易导致bug，所以这种方式是无法使用的。

由于上面的2个方式都有问题，所以C++采用了暴力终止程序的方式，实际上C++的这种做法强迫程序员必须保证std::thread销毁时有正确的行为，否则，你的程序就会被干掉。这是C++的哲学，其他语言对于这个问题并不一定使用这种方式。

Meyers的建议是“Make std::threads unjoinable on all paths”，也就是让std::thread在销毁时是unjoinable的。这是一种trade-off, 和之前的第一种做法一样会导致潜在的性能问题。但是相比于其他两种选择：程序被终止；detach的undefined行为，这是可以接受的（对于性能问题，可以通过实现interruptible threads来弥补）。

为了确保“Make std::threads unjoinable on all paths”，那么在函数返回和异常发生时，thread要是unjoinable状态的，所以可以用RAII来完成：

class ThreadRAII
{
public:
    enum class DtorAction { join, detach };
public:
    ThreadRAII(std::thread&& t, DtorAction act)
        :m_action(act), m_thread(std::move(t)) {}

    ~ThreadRAII()
    {
        if (m_thread.joinable())
        {
            if (m_action == DtorAction::join)
                m_thread.join();
            else
                m_thread.detach();
        }
    }

    ThreadRAII(ThreadRAII&&) = default;
    ThreadRAII& operator=(ThreadRAII&&) = default;

    std::thread& get() { return m_thread; }

private:
    std::thread m_thread;
    DtorAction m_action;
};

ThreadRAII构造函数接收std::thread rvalue，因为std::thread不可复制，调用move之后，传进来的std::thread就变成了unjoinable的，执行任务就转移给了ThreadRAII的std::thread。

有了ThreadRAII，就可以安全地使用std::thread：

void doSomething()
{
    ThreadRAII t(std::thread([]
    {
       ....
    }
    ));
    if(someCondition())
    {
        t.get().join();
        ...
    }
}