下面这段代码，如果调用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();
...
}
}