【C++如何创建一个线程】

线程管理的基础

启动线程

通常启动一个线程代码如下：

// code1 
#include <iostream>
#include <thread>
void do_something(int a){
    std::cout << "do_something and arg is " << a << std::endl;
}
int main()
{
	std::thread t(do_something, 3); // 创建线程,入口函数是do_something, 传入的参数是3 
	t.join(); // 让主线程等待子线程，不等待子线程可能主线程运行完毕整个程序就已经
		      // 结束了，子线程得不到运行
}

// 输出:
do_something and arg is 3

如同大多数C++标准库一样，std::thread 可以用可调用（callable）类型构造，将带有函数调用符类型的实例传入std::thread 类中，替换 默认的构造函数。

#include <iostream>
#include <thread>

void do_something(int){
    std::cout << "do_something" << std::endl;
}

void do_something_else()
{
    std::cout << "do_something_else" << std::endl;
}

class background_task
{
public:
    background_task()
    {
        std::cout << "background_task()" << std::endl;
    }
    void operator()() const  // 符号重载
    {
        do_something();
        do_something_else();
    }
    void normal_task()
    {
        std::cout << "normal_task" << std::endl;
    }
    ~background_task()
    {
        std::cout << "~background_task()" << std::endl;
    }
};


int main(void)
{
    background_task f;
    std::thread  t(f);  // 线程传入background_task类f，传入的函数的参数是void 空类型
    t.join();
    
}

// 输出
background_task()  // 第一次构造：background_task f
do_something			// std::thread t(f) 因为重载了f的括号操作符并且重载传入的参数是void，do_something 
						//所以执行和do_something_else, 其中线程传参数为void
do_something_else
// 代码中，提供的函数对象会复制到新线程的存储空间当中，函数对象的执行和调用都在线程的内存空间中进行
~background_task() // 析构两次是因为线程中执行了background_task的默认拷贝构造函数，线程结束线
				   // 线程内部析构一次
~background_task() // main 函数中的background_task f 析构一次。
~background_task()

《C++并发编程实战》：代码中，提供的函数对象会复制到新线程的存储空间当中，函数对象的执行和调用都在线程的内存空间中进行。函数对象的 副本 应与原始函数对象保持一致，否则得到的结果会与我们的期望不同。
析构三次的原因可能是std::thread 还存了一份副本

！！！由于C++的语法解析，所以不能向std::thread 中传入临时变量，C++编译器会将其解析为函数声明

线程中传递参数

一般线程传递参数

void fun(int a)
{
    std:: cout << "fun a is " << a << std::endl;
}

int main(void)
{
    int a = 3;
    std::thread t(fun, a);
}

向线程调用的函数传递参数，线程通常会在自己的内存中先拷贝一份该参数，调用的函数再去接收线程内存中拷贝的参数

class Test
{
public:
    Test()
    {
        std::cout << "Test()" << std::endl;
    }
    Test(const Test& test)
    {
        std::cout << "&Test()" << std::endl;
    }
    ~Test()
    {
        std::cout << "~Test()" << std::endl;
    }
};

void fun(Test t)
{
    std:: cout << "Test" << std::endl;
}

int main(void)
{
    Test test;
    std::thread t(fun, test);
    t.join();
}

转移线程所有权

一个线程的所有权是可以使用**std::move()**函数转移给其他线程的，转移之后，由其他线程接管当前线程。

void some_function();
std::thread t1(some_function); 
std::thread t2 = std::move(t1);

或者通过函数的返回值把函数返回值把线程的所有权移交给新线程，如下。

#include <iostream>
#include <thread>
#include <unistd.h>

void do_some_thing()
{
    usleep(2000 * 1000);
    std::cout << "do_some_thing()" << std::endl;
}

std::thread fun()
{
    std:: cout << "fun" << std::endl;
    std::thread t(do_some_thing);
    usleep(10000);
    return t;
}

int main(void)
{

    std::thread t = fun(); // fun函数中的线程被main中的t接管，整个程序中只会执行一次 do_some_thing();
    t.join();

}

所有权可以在函数内部当成参数传递

void f(std::thread t);
void g()
{
  void some_function();
  f(std::thread(some_function));
  std::thread t(some_function);
  f(std::move(t));
}

运行时刻决定线程的数量

std::thread::hardware_concurrency()

该函数将返回能同时并发在一个程序中的线程数量。例如，多核系统中，返回值可以是CPU核芯的数量。返回值也仅仅是一个提示，当系统信息无法获取时，函数也会返回0。
PS：该文章内容整理于 C++并发编程实战这本书。