C++11线程常识

定义一个线程

#include 
#include 
#include 

void doSomething()
{
  while(true)
  {
     std::cout << "hello world" << std::endl;
     std::this_thread::sleep_for(std::chrono::seconds(1));
  }
}

int main()
{
  std::thread t(doSomething);  //① 
  if(t1.joinable())
  {
    t1.join();                 //②
  }
}

以上代码简单的顶一个线程，主线程阻塞等待子线程退出，子线程每个一秒打印一个"hello world". 代码中① 声明定义了一个线程，我们往thread对象t中传入一个函数指针，此后线程开始运行，该回调函数被调用。代码②调用了std::thtrad::join()函数，该函数表示子线程与主线程的关系，主线程在此处将会等待子线程结束，并回收子线程的资源(一般一个子线程将会占用32M左右的内存，如果无线开启线程而不加以回收，那么系统将会资源耗尽)，需要注意的是，我们在调用std::thtrad::join()函数之前需要检查这个线程是否是可以join的，否则会出现core_dump。
除了std::thtrad::join()，std::thread还提供了std::thtrad::detach()函数，该函数表示主线程和子线程的关系是分离的，当子线程结束时，其占用的内存将自动释放。
另一个值得注意的是，如果在thread对象被销毁时还没有决定好线程销毁的方式(join/detach), 那么在thread对象被销毁时，析构函数将会调用std::terminate()终止程序。

传递参数

上一节中我们的线程接收的函数指针没有参数列表，那么如果有参数，或者参数还有const &, &&等限定符，该怎么办呢，参考以下代码:

void doSomething(const int& num, std::string&& str)
{
  while(true)
  {
     std::cout << str << std::endl;
     std::this_thread::sleep_for(std::chrono::seconds(num));
  }
}

int main()
{
  int num = 1;
  std::string str("hello world");
  std::thread t1(doSomething, std::ref(num), std::move(str));  //① 
  if(t1.joinable())
  {
    t1.join();                 //②
  }
}

1. 如果参数类型是一个拷贝，那直接传递，没有任何花里胡哨
2. 如果参数类型是引用，那么可参考std::bind的语法，需要使用std::ref将其声明为一个引用
3. 如果是右值应用，那么需要使用std::move将其声明为一个右值引用

移交线程归属权

STL库中有许多对象是资源独占型的，比如一个众所周知的例子就是std::unique_ptr, 其实现原理其实就是，拷贝构造函数和复制重载运算符被delete掉了，例如:

unique_ptr(const unique_ptr&) = delete;
uuique_ptr& operator=(const unique_ptr&) = delete;

虽然std::thread是无法复制的，但是他是可以移动的(其实现依赖右值引用)。因此我们可以写下如下代码:

int main() 
{
  std::thread t1([](){
    while(1)
    {
      std::this_thread::sleep_for(std::chrono::seconds(1));
      std::cout << "hello" << std::endl;
    }
  });

  std::thread t2([](){
    while(1)
    {
      std::this_thread::sleep_for(std::chrono::seconds(1));
      std::cout << "world" << std::endl;
    }
  });

  //t1.detach();
  t1 = std::move(t2); //③
  
  if(t1.joinable())
  {
    t1.join();
  }
  if(t2.joinable())
  {
    t2.join();
  }


  return 0;
}

以上代码将会在③处出现错误，std::terminate()将会被调用，因为t1重新接收了t2，而t1原来的实例将被释放，但却没指定其方式是join还是detach。因此我们需要将③行之前的注释解开。

相关函数

最大线程数

中所周知啊，如果在单核cpu上，所有的程序都是顺序执行的，但我们依然可以进行多线程操作，这是因为系统在执行过程中频繁的从多个线程之间切换任务，于是给用户以程序并行的体验，但是这个操作势必会带来更多的资源消耗。标准库中提供一个函数std::thread::hardware_concurrency()，该函数返回系统最大支持线程数的一个指标，之所以叫他指标是因为如果资源数无法获取，那么函数将返回0。因此我们要注意尽信书不如无书。

线程表示符

可使用std::this_thread::get_id()得到当前线程的id。

阻塞线程

可使用std::this_thread_sleep_for(std::chrono::second(1));使线程阻塞1s，该操作会将线程挂起，因此不会对CUP造成过多负载。