不要用std::thread写裸线程

我们先看一段代码：

#include <iostream>
#include <thread>
#include <unistd.h>
using namespace std;
volatile bool flag = false;
void f1() {
  for (int i = 0; i < 1000; ++i) {
    if (flag) cout << i << " catched" << endl;
    else cout << i << " running" << endl;
    usleep(10000);
  }
}
void f2() {
  sleep(1);
  flag = true;
  throw 1;
}
void run1() {
  thread thr(f1); 
  f2();           
  thr.join();
}
int main()
{
  try {
    run1();
  } catch(...) {
  }
  while(1);
}

这段代码中，我们在run1里面发射了一个线程f1，f1是做一个计数工作，在run1里面运行f2，f2在休眠1秒之后抛异常。

运行结果是： 当f2抛异常之后，程序就挂掉了。

这是为什么呢？因为在f2抛出异常之后，run1发生调用栈回退的时候，析构thr了。在析构thr的时候，我们可以看一下gcc的源代码：

~thread()
 {
   if (joinable())
     std::terminate();
 }

一旦这个句柄是没有join就调用析构函数，那么调用std::terminate()，这就是程序挂掉的原因。

到这里，似乎就引入了一个疑问，到底这个时候析构了thr，我们更希望发射出来的线程f2应该怎么运行呢？真的希望程序挂掉吗？

分析起来，大致可以有下面两种看起来合理的情况：

1、我们可能希望调用栈回退的时候，等f2运行完，join之后，才完成调用栈回退

2、我们可能希望把f2剥离句柄thr的控制，自己单独运行

这上面两种情况都是可以实现的，我们分别都看一下。我们先来看第一种实现：

class SafeThread {
private:
  std::thread thr_;
public:
  template< class Function, class... Args > 
  explicit SafeThread(Function&& f, Args&&... args) {
    std::thread thr(f, args ...);
    thr_.swap(thr);
  }
  ~SafeThread() {
    thr_.join();
  }
};

通过这么实现，放到第一段代码的情境中，就会是这样子：

void run1() {
  SafeThread thr(f1); 
  f2();           
}

这是RAII的实现方式，在离开作用域的时候析构，而我们在析构的时候完成join的工作。那么，在发生刚才那种情况的时候，异常一旦抛出，run1就要做栈回退，当调用thr的析构函数的时候，自然就会join，等待f1的执行完毕。

接着我们看一下第二种实现：

class SafeThread {
  //...同上一种
  ~SafeThread() {
    thr_.detach();
  }
};

大部分和第一种实现一样，不同之处在于，当调用析构函数的时候，把线程剥离句柄（就像脱缰的野马）

最后分析一下两种方式的

1、第一种方式，可以像原有逻辑一样，在完成f1线程之后，才结束run1函数。但是，无法及时处理异常

2、第二种方式很不推荐，一旦f1线程使用了run1提供的局部对象作为运行参数，那么一旦run1调用回退了，局部变量被回收，而f1继续使用，程序就错掉了，能段错误是最好的结局了。

总结，用RAII的方式封装std::thread，按第一种方式实现，是一个不错的选择。

参考：http://akrzemi1.wordpress.com/2012/11/14/not-using-stdthread/