C++并发编程学习——2.管理线程

基本线程管理

（1）每个C++程序至少有一个线程，它在运行程序时启动，运行着main函数。

当线程运行完它的初始函数时，该线程就会退出。

（2）启动线程

线程是通过构造 std:thread 对象 来开始的。

void do_some_work();   //函数
std::thread my_thread(do_some_work);  //thread对象

thread构造函数可以传入任何的可调用对象 ，例如：

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

一旦开始了线程，必须要显示的决定是等待它完成( join )，还是让它自行运行( detach )。如果在thread对象被销毁前还没有决定（调用join或者detach），那么程序会被终止（thread的析构函数会调用std::terminate()）。

/*
 * 代码2.1
 */
struct func
{
  int &i; //注意，传入的是引用。所以i的生命周期和func对象无关
  func(int &i_) : i(i_){}
  void operator()()
  {
    for (unsigned j = 0; j < 100000; j++)
    {
      do_something(i); //可能发生悬空引用的访问
    }
   }
};

void oops()
{
  int some_local_state = 0;
  func my_func(some_local_state);
  std::thread my_thread(my_func);
  my_thread.detach(); //不等待线程的完成
  //my_thread线程可能还在运行，但是some_local_state已经被销毁
}

（2）等待线程完成

如果需要等待线程完成，通过thread对象调用 join() 来实现。调用join()对象的线程会阻塞直到该线程返回。

一个线程只能调用一次join()，调用后调用 joinable() 返回false，即该thread对象无法再次调用join()。

（3）异常环境下的等待

如果要分离线程，那么通过线程启动后就可以分离线程。但是对于join线程，要考虑选择在哪个位置调用join()。

在异常环境下，对于存在异常时也要调用join，防止因为异常而跳过了join。

但是这样使用容易把作用域弄乱，所以不是一个理想的方案。更好的方法是使用资源获取即初始化（RAII），提供一个类，在它的析构函数中进行join()。

class thread_gurad
{
  std::thread &t;
public:
  thread_gurad(std::thread &t_) : t(t_){}
  ~thread_gurad()
  { //析构时调用join，保证线程的退出
    if (t.joinable())
    {
      t.join();
    }
  }
  thread_gurad(thread_gurad cosnt &) = delete;
  thread_gurad& operator=(thread_gurad const &) = delete;
};
struct func;
void f()
{
  int some_local_state = 0;
  func my_func(some_local_state);
  std::thread t(my_func);
  thread_gurad g(t);
  do_some_thing();
  //先销毁g，销毁g时调用了t.join()，保证了线程退出
  //线程执行完再销毁了some_local_state
}

（4）在后台运行线程

在thread对象调用detach()，会把线程丢在后台运行，没用方法通信。被分离的线程通常称为守护线程，无需用户界面，只运行在后台。

只能在t.joinable()返回true时，在能调用detach()。

传递参数给线程函数

（1）传递参数给线程的启动函数，就是传递给thread对象的构造函数。

参数会以默认的方式被复制（copy）传递给线程的存储空间，从而被线程访问，即使参数类型是引用。 （和std::bind传递参数的传递方式相同）

void f(int i, std::string const &s);
std::thread t(f, 3, "hello"); //传递了参数

因此有些情况下，你想到的是引用，但是对象只会被复制，例如：

void update_data_for_widget(widget_id w, widget_t &data);
void oops_again(widget_t w)
{
  widget_data data;
  std::thread t(update_data_for_widget, w, data); //传递的是data的复制的引用！
  display_status();
  t.join();
  process_widget_data(data); //data值没有改变
}

当对thread对象传入data时，传递给新线程的是data在内部的副本的引用而不是对data本身的引用，所以在oops_again中data的值不会被t线程改变。

可以使用std::ref来包装确实需要被引用的参数：

std::thread t(update_data_for_widget, w, std::ref(data));

转移线程的所有权

（1）std::thread的实例对象只能是 可移动的(move)，是不可复制的(copy) 。这确保了任意时刻只有一个对象与某个特定的执行线程相关联，即线程只有一条执行路径。（类似std::ifstream,std::unique_ptr）

std::thread对移动的支持同时考虑了std::thread对象的容器，这些容器也是移动感知的。

void do_work(unsigned id);
void f()
{
  std::vector<std::thread> threads;
  for (unsigned i = 0; i < 20; ++i)
  {
    threads.push_back(std::thread(do_work, i)); //调用的是移动拷贝
  }
  std::for_each(threads.begin(), threads.end(),
  std::mem_fn(&std::thread::join)); //轮流在每个线程上调用join()
}

在运行时选择线程数量

std::thread::hardware_currency() ，这个函数返回一个对于给定程序执行时能够真正并发的线程数量的知识。例如，在多核系统上它可能返回的是CPU的数量，返回0表示信息不可用。

标识线程

线程标识符是 std::thread::id类型 的。线程标识符可以通过thread对象调用 get_id()函数 来返回。另外，当前执行的线程标识符可以使用 std::this_thread::get_id() 获得。

std::thread::id类型的对象可以自由的复制和比较。如果二个线程标识符相等，代表他们代表同一个线程或者都没有相关线程。

std::thread::id的实例常常用于检查一个线程是否需要执行某些操作。

if(std::this_thread::get_id() == master_thread)
{
do_master_thread_work()；
}