目录
std::thread详解
（1）启动线程
①无参无返回的函数作为入参
②函数对象（仿函数）作为入参
（2）不等待线程detch()
（3）等待线程完成join()
（4）向线程函数传递参数
（5） 转移线程所有权
（6）标识线程id
std::thread详解
每个程序至少有一个线程：执行main()函数的线程，其余线程有其各自的入口函数。线程与原始线程（以main()函数为入口函数的线程）同时运行。如同main()函数执行完退出一样，当线程执行完入口函数后，线程也会退出。在为一个线程创建了一个 std::thread 对象后，需要等待这个线程结束。
（1）启动线程
线程在 std::thread 对象创建（为线程创建指定任务）时启动。使用C++线程库启动线程就是构造 std::thread 对象。使用时需要引入头文件 <thread> 。
std::thread 构造函数：
| 构造函数 | 语法格式 | 备注 |
| 默认构造函数 | thread() noexcept; | 创建一个空的std::thread 对象 |
| 初始化构造函数 | template <class Fn, class... Args> explicit thread(Fn&& fn, Args&&... args); | 创建一个std::thread 对象该对象可以被joinable，新产生的线程会调用fn函数，该函数的参数由 args 给出。 |
| 拷贝构造函数[delete] | thread(const thread&) = delete; | 禁用，std::thread 对象不可拷贝构造 |
| 移动构造函数 | thread(thread&& x) noexcept; | 调用成功之后，x就不代表任何thread对象了 |
①无参无返回的函数作为入参
#include <thread>
void do_work();
std::thread mythread(do_work);do_work()函数在其所属的线程上允许，直到函数执行完毕，线程也就结束了。
②函数对象（仿函数）作为入参
#include <iostream>
#include <thread>
using namespace std;
class Test
{
public:
void operator()()const
{
cout << "hello world" << endl;
}
};
int main()
{
//Lambda表达式创建的匿名函数对象
thread mythread([] {cout << "hello world" << endl; });
//1和2都是函数对象
//thread testthread((Test())); //1
thread testthread{ Test() };//2 新统一的函数对象初始化语法
mythread.join();
testthread.join();
}启动线程后，需要明确是等待线程结束(join)还是让其自主运行(deatch)。
必须在 std::thread 对象销毁之前做出决定，否则程序就会终止（ std::thread 的析构函数函数会调用 std::terminate(),这时再决定会触发相应的异常）。
- detach方式，启动的线程自主在后台运行，当前的代码继续往下执行，不等待新线程结束。
- join方式，等待启动的线程完成，才会继续往下执行。
（2）不等待线程detch()
detach()线程： 将当前线程对象所代表的执行实例与该线程对象分离，使得线程的执行可以单独进行。一旦线程执行完毕，它所分配的资源将会被释放。
调用 detach 函数之后：
*this不再代表任何的线程执行实例。- joinable() == false
- get_id() == std::thread::id()
另外，如果出错或者 joinable() == false，则会抛出 std::system_error。
示例演示：
void thread01()
{
for (int i = 0; i < 5; i++)
{
cout << "Thread 01 is working ！" << endl;
Sleep(10);
}
}
void thread02()
{
for (int i = 0; i < 5; i++)
{
cout << "Thread 02 is working ！" << endl;
Sleep(20);
}
}
int main()
{
thread task01(thread01);
thread task02(thread02);
task01.detach();
task02.detach();
for (int i = 0; i < 5; i++)
{
cout << "Main thread is working ！" << endl;
Sleep(20);
}
由上图主线程结果和子线程结果无规则输出可知，detach方式主线程和子线程是自主运行的，互不干扰。
如果不等待线程，就必须保证线程结束之前，可访问的数据的有效性。例如：对象销毁之后再去访问，就会产生未定义的错误。这种情况很可能发生再线程还没结束，函数已经退出的时候，这时线程函数还持有函数局部变量的指针或引用。
class func
{
public:
int& i;
func(int& i_) : i(i_) {}
void operator() ()
{
for (unsigned j = 0; j < 1000000; ++j)
{
do_something(i); // 1 潜在访问隐患：悬空引用
}
}
};
void oops()
{
int some_local_state = 0;
func my_func(some_local_state);
std::thread my_thread(my_func);
my_thread.detach(); // 2 不等待线程结束
} // 3 新线程可能还在运行
//如果线程还行运行，就会调用do_something（i）函数，就会访问一个已经销毁的变量。
解决方案：将数据复制到线程中，而非复制到共享数据中。
也可以通过join()函数来确保线程在函数完成前结束。
（3）等待线程完成join()
如果需要等待线程，可以使用join()函数。 my_thread.detach()改为my_thread.join() 就可以确保局部变量在线程完成后才销毁。调用join()的行为，还清理了线程相关的存储部分，这样 thread 对象将不再与已经完成的线程有关联。这意味着，只能对一个线程使用一次join();一旦使用过join()，thread 对象就不能再次join()，当对其使用joinable()时，将返回false。
示例演示:
void thread01()
{
for (int i = 0; i < 5; i++)
{
cout << "Thread 01 is working ！" << endl;
Sleep(10);
}
}
void thread02()
{
for (int i = 0; i < 5; i++)
{
cout << "Thread 02 is working ！" << endl;
Sleep(20);
}
}
int main()
{
thread task01(thread01);
thread task02(thread02);
task01.join();
task02.join();
for (int i = 0; i < 5; i++)
{
cout << "Main thread is working ！" << endl;
Sleep(20);
}
} 
由上图主线程结果都在子线程结果后面输出可知，join使得调用thread01()和thread02()的线程task01和task02发生阻塞，直到由阻塞的线程执行完毕后，主线程才执行。
joinable(): 检查线程是否可被 join。检查当前的线程对象是否表示了一个活动的执行线程，由默认构造函数创建的线程是不能被 join 的。另外，如果某个线程已经执行完任务，但是没有被 join 的话，该线程依然会被认为是一个活动的执行线程，因此也是可以被 join 的。
【小结】
如果想要分离一个线程，可以在线程启动后，直接使用detach() 进行分离。
如果打算等待对应的线程，则需要挑选join()的位置。当在线程运行之后产生异常，在join()调用之前抛出，就意味着这次调用会被跳过。
（4）向线程函数传递参数
创建std::thread 对象时，向构造函数中的可调用对象或函数传递参数，和普通的函数差不多，对应函数参数顺序依次传入即可。
【注意】默认参数是以引用的形式拷贝到线程独立内存中。
#include <iostream>
#include <thread>
void func1(int a)
{
a = 100;
cout << "func1:" << a << endl;
}
void func2(int& a)
{
a = 100;
cout <<"func2:"<< a << endl;
}
int main()
{
int a = 10;
std::thread t1(func1, a);//++++++++ 1 编译成功
//通过初始化构造函数，创建了一个std::thread对象t1，新产生的进程会调用func1,该函数的参数为a
t1.join();
cout <<"Main:"<< a << endl;
//std::thread t2(func2, a);//++++++++2 编译失败
std::thread t2(func2, std::ref(a));//++++++3 编译成功
t2.join();
cout <<"Main:" << a << endl;
a++;
std::thread t3(func2, std::ref(a));
std::thread t4(std::move(t3));//++++++++++4 编译成功
t4.join();
cout << "Main:" << a << endl;
}
①中使用std::thread 构造函数创建对象t1时，参数a是以拷贝进行值传递的，所以子进程对a的修改，只对子进程独立内存中的a起作用，并不影响主进程的a。
func2 期待传入一个引用参数，但是std::thread 的构造函数2并不知晓；构造函数无视函数期待的参数类型，并盲目的拷贝已提供的变量。代码将参数以右值的方式进行拷贝传递，并被函数func2调用。因为函数期待是一个非常量引用作为参数，而非一个右值作为参数，所以编译时出错。
解决方案：使用 std::ref 将参数转换成引用的形式。如3所示即可。
③中参数是引用方式传递，相当于子进程和主进程共享参数a,所以子进程对参数a的修改，同样影响了主进程的a.
④中使用移动构造函数将t3对象的资源移动给t4,t3不再是thread对象，不起作用了，func2在线程对象t4正常运行，并由于是引用传递，所以也更改了主线程a的值。
（5） 转移线程所有权
上面示例4中运用到了一个移动 std::move操作。C++标准库中有许多资源占有类型，比如 std::ifstream ,std::unique_ptr和std::thread 都是可移动的，但不可拷贝。当要写一个后台启动线程的函数，并想通过新线程返回的所有权去调用这个函数，而不是等待线程结束再去掉用。
void some_function();
void some_other_function();
std::thread t1(some_function); // 1
std::thread t2=std::move(t1); // 2
t1=std::thread(some_other_function); // 3新线程开始与t1相关联①。当显式使用std::move创建t2后②，t1的所有权就转移给了t2。之后，t1和执行线程已经没有关联了，执行some_function的函数线程与t2关联。
然后，一个临时std::thread 对象相关的线程启动了③。为什么不显式调用std::move()转移所有权呢？因为，所有者是一个临时对象——移动操作将会隐式的调用。
std::thread 赋值操作：
| 函数名称 | 函数原型 | 备注 |
| 移动赋值 | thread& operator=(thread&& rhs) noexcept; | 移动赋值，如果当前对象不可joinable，需要传递一个右值引用给move赋值操作；如果当前对象可被joinable，则会调用terminate()报错。 |
| 拷贝赋值 | thread& operator=(const thread&) = delete; | 被禁用，所以std::thread对象不可拷贝 |
std::thread t3; // 4
t3=std::move(t2); // 5
t1=std::move(t3); // 6 赋值操作将使程序崩溃t3使用默认构造方式创建④，与任何执行线程都没有关联。调用 std::move()将与t2关联线程的所有权转移到t3中⑤。因为t2是一个命名对象，需要显式的调用std::move()。移动操作 #5 完成后，t1与执行some_other_function的线程相关联，t2与任何线程都无关联，t3与执行some_function的线程相关联。
最后一个移动操作，将some_function线程的所有权转移⑥给t1。不过，t1已经有了一个关联的线程(执行some_other_function的线程)，所以这里系统直接调用std::terminate()终止程序继续运行。这样做（不抛出异常，std::terminate()是noexcept函数)是为了保证与std::thread的析构函数的行为一致(说明：不能通过赋一个新值给std::thread对象的方式来”丢弃”一个线程)。
线程的所有权转移场景：
①函数返回std::thread 对象（所有权在函数外进行转移）
void do_task()
{
cout << "do_task" << endl;
}
std::thread function()
{
void do_task();
return std::thread(do_task);
}
int main()
{
std::thread task01 = function();
task01.join();
cout << "main end" << endl;
}②std::thread 对象作为参数 （所有权在函数内部传递）
void do_task()
{
cout << "do_task" << endl;
}
void function(std::thread t)
{
t.join();
}
int main()
{
std::thread t(do_task);
function(std::move(t));
cout << "main end" << endl;
}（6）标识线程id
线程标识类型为 std::thread::id ,可以通过两种方式进行检索。
一是，通过调用std::thread对象的成员函数 get_id () 来直接获取。如果std::thread对象没有与任何线程相关联，get_id()将返回std::thread::type 默认值，这个值表示“无线程”。
二是，当前线程中调用 std::this_thread::get_id() ,这个函数定义在<thread>头文件中，也可以获得线程标识。
std::thread::id对象可以自由拷贝和对比，因为标识符可以复用。
如果两个对象的id相等，那么它们是同一个线程，或都是“无线程”。如果不等，那就代表两个不同线程，或一个有线程，另一个没有线程。
void do_master_task() {
cout << "do master task" << endl;
}
void do_other_task() {
cout << "do other task" << endl;
}
int main()
{
std::thread::id master_id = std::this_thread::get_id();
thread mythread([] {cout << "open child thread" << endl; });
mythread.join();
if (std::this_thread::get_id() == master_id)
{
do_master_task();
}
else {
do_other_task();
}
}
