2.1线程管理基础

启动线程

使用C++线程库启动线程可以归结为构造std::thread对象：

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

std::thread可以用可调用（callable）类型构造，将带有函数调用符类型的实力传入std::thread类中，替换默认的构造函数。

class back_ground
{
  public:
    void operator()() const
    {
        do_something();
        do_something_else();
    }
};
background_task f;
std::thread my_thread(f);

【注意】当函数对象传入到线程构造函数中时，要避免语法解析，如果传递了一个临时变量而不是一个明明的变量；C++编译器会将其解析为函数声明，而不是类型对象的定义。
例如：

std::thread my_thread(background_task());

使用前面命名函数对象的方式，或使用多组括号，或使用新统一的初始化语法，或者使用lambda表达式，可以避免这个问题。如：

std::thread my_thread((background_task()));
std::thread my_thread{background_task()};
std::thread my_thread([]{
  do_something();
  do_something_else();
});

启动了线程需要明确是要等待线程结束，还是让其自主运行。如果std::thread对象销毁之前还没有做出决定，程序就会终止，因此即便有异常存在，也需要确保线程能够正确的加入（joined）或分离（detached）

2.1.2等待线程的完成

只能对一个线程使用一次join();一旦使用过join(),std::thread对象就不能再次加入，当对其使用joinable()时，将返回否（false）。

特殊情况下的等待

避免应用被抛出的异常所终止，就需要做出一个决定。通常当倾向于在无异常的情况下使用join()时，需要在异常处理的过程中调用join()，从而避免生命周期的问题。

struct func;
void f()
{
  int some_local_state = 0;
  func my_func(some_local_state);
  std::thread t(my_func);
  try
  {
    do_something_in_current_thread();
  }
  catch(...)
  {
    t.join();
    throw();
  }
  t.join();
}

如何确保线程在函数之前结束？
使用资源获取即初始化方式（RAII， Resource Acquisition Is Initialization），并且提供一个类，在析构函数中使用join()

class thread_guard
{
  std::thread& t;
  public:
  explicit thread_guard(std::thread& t_): t(t_) {}
  ~thread_guard()
  {
    if(t.joinable()) // 1
    {
      t.join(); // 2
    }
  } 
  thread_guard(thread_guard const&)=delete; // 3
  thread_guard& operator=(thread_guard const&)=delete;
};
struct func; 
void f()
{
 int some_local_state=0;
 func my_func(some_local_state);
 std::thread t(my_func);
 thread_guard g(t);
 do_something_in_current_thread();
}

后台运行程序

对一个std::thread对象使用detach()就会将这个线程搁置在后台运行，这就意味着不能与这个线程产生直接交互。
因为C++运行库保证，当线程退出时，其相关资源的能够正确的回收，所以后台线程的归属和控制都会交给C++运行库处理。
分离线程的使用场景？
通常， 称分离线程为守护线程（ daemon threads） 。 在UNIX中守护线程是指， 运行在后台，且没有任何可用用户接口的线程。 这种线程的特点就是长时间运行；它们的生命周期可能会从某一个应用起始到结束， 也会在后台执行诸如监事文件系统的任务， 还有可能对未使用的缓存进行清理， 亦或对数据结构进行优化。 另一方面， 它也使用分离线程的另一种机制， 确定线程什么时候结束， 或者在“发后即忘”（ fire and forget） 的任务在哪里使用到了这个线程。

使用条件
为了从一个 std::thread 对象中分离一个线程（ 前提是有一个可进行分离的线程） ：你不能对没有执行线程的 std::thread 对象使用detach()。

void edit_document(std::string const& filename)
{
    open_document_and_display_gui(filename);
    while(!done_editing())
    {
        user_command cmd=get_user_input();
        if(cmd.type==open_new_document)
        {
            std::string const new_name=get_filename_from_user();
            std::thread t(edit_document,new_name); // 1
            t.detach(); // 2
        } 
        else
        {
            process_user_input(cmd);
        }
    }
}