一，启动线程

1. 使用C++线程库启动线程，即为构造std::thread对象：

void do_some_work();
std::thread my_thread( do_some_work );

std::thread构造方法

class A
{
public:
  void operator()() const
  {
     std::cout << "hello" << std::endl;
  }
};

A a;
std::thread my_thread(a);

std::thread my_thread(a);调用函数对象a() 传入thread中 ，并把函数对象a 复制到新线程的存储空间中，函数对象的执行和调用都在线程的内存空间中进行。

注意：

• 如果你传递给thread是一个临时变量，而不是一个已经声明的变量时，会出现C++最令人头痛的语法解析（C++’s most vexing parse），C++编译器解析出的结果将会与你所想的出入很大：

std::thread my_thread( A() );//A()是一个临时的函数对象

这段代码被解析为：
这是一个函数声明，函数名为my_thread。它可以接收一个没有参数的，并且会返回对象A的函数指针。my_thread函数的返回值是std::thread类型。

怎么解决?
使用多组括号，初始化语法 或者 前面代码 都可以避免这个问题：
std::thread my_thread( (A()) );
std::thread my_thread{ A() };

• 如果不等待线程，必须保证线程结束之前，数据的有效性

struct F
{
  int &i;
  func(int &i_) : i( i _ )  { }

  void operator() ()
  {
    for(unsigned j = 0; j < 100000; ++j)
    {
        std::cout << i << std::endl;
     }
  }
}

void oop()
{
   int number = 0;
   F my_f(unmber);
   std::thread my_f(my_f);
   my_f.detach();
}

由于不等待线程结束， 当oop()执行完成时, 新线程中的函数可能还在运行。 如果线程还在运行， 它就会去调用do_something(i)函数，这时，引用对象 i 已经被销毁了。

二，等待线程完成

如果需要等待线程， std::thread 实例可以使用join()。

class func1{//仿函数对于多线程的运用
public:
    int &a;
    explicit func1(int &a_) : a(a_) {}

    int operator()(int c)
    {
        for(;a < c; ++a)
        {
            cout << a << endl;
        }
        cout << a << endl;
        return a;
    }
};

int main()
{
    int st = 6;
    func1 f(st);

    int c = 10;
    std::thread my_thread (f, c);
    my_thread.join();

    return 0;
}

三，特殊情况下的等待

当倾向在无异常的情况下使用join()时， 需要在异常处理过程中调用join()， 从而避免生命周期的问题。

• 可以通过使用“资源获取即初始化方式”(RAII， Resource Acquisition Is Initialization)解决此问题。它提供一个类， 在析构函数中使用join()：

struct F
{
  int &i;
  func(int &i_) : i( i _ )  { }

  void operator() ()
  {
    for(unsigned j = 0; j < 100000; ++j)
    {
        std::cout << i << std::endl;
     }
  }
}

class G
{
  std::thread& t;

public:
  explicit G(std::thread& t_) : t(t_) {}
  ~G()
  {
    if(t.joinable()) 
    {
      t.join(); 
    }
  } 

  G( G const& )=delete;//不让编译器自动生成，因为这可能会弄丢已经加入的线程。
  G& operator= ( G const& )=delete;
};

struct F;

void oop()
{
  int data = 0;
  F struct_my_f(data);
  std::thread my_t(struct_my_f);
  G my_g(t);
  do_something_in_current_thread();
} 

函数oop() 执行完，对象my_g 也会被销毁， 即使do_something_in_current_thread() 抛出一个异常， 这个销毁依旧会发生。

四，后台运行线程

如果不想等待线程结束， 可以分离(detaching)线程， 从而避免异常安全(exception-safety)问题。 由于使用detach()会让线程在后台运行，如果线程分离， 那么就不可能有 std::thread 对象能引用它， 分离线程的确在后台运行， 所以分离线程不能被加入。

一个可结合的线程能够被其他线程收回其资源和杀死；在被其他线程回收之前，它的存储器资源（如栈）是不释放的。相反，一个分离的线程是不能被其他线程回收或杀死的，它的存储器资源在它终止时由系统自动释放。

注意：

当在 std::thread 对象中分离线程时，不能对没有执行线程的 std::thread 对象使用detach()。因为和 join()的使用条件相同， 所以可以用同样的方式进行检查，当 std::thread 对象使用 t.detach() 之前，先使用t.joinable()检测该线程是否为可执行线程，如果返回的是true，就可以使用了。