2. 线程管控

本节来讨论线程的一些基本管控，比如啥时候启动，啥时候关闭。

开启

用线程对象来管理，简单说就是初始化一个线程对象：

#include <thread>
int main()
{
	std::thread t(可调用类型)；
	//可调用类型包括函数和函数对象以及lamda表达式
}

收尾

一旦线程开启后，main所在的线程就开始干自己的事情，那么问题来，t这个线程对象中的线程怎么处理？

#include <thread>
int main()
{
	std::thread t(可调用类型)；
	//可调用类型包括函数和函数对象以及lamda表达式
	DoSomething();
	//t.join(); 
	t.detach();
}

有两种方式，二选一：join和detach

joinable

在了解join之间，我们先熟悉一下thread对象的一个属性，叫做joinable, 可以用t.joinable()查看改属性值，到底这个属性是啥意思呢？我自己理解就是这个线程对象中是否还有要管理的线程函数,下面是一个代码测试：

#include <iostream>
#include <thread>
#include <chrono>
 
void foo()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}
 
int main()
{
    std::thread t;
    std::cout << "before starting, joinable: " << std::boolalpha << t.joinable()
              << '\n';
 
    t = std::thread(foo);
    std::cout << "after starting, joinable: " << t.joinable() 
              << '\n';
 
    t.detach();
    //t.join();
    std::cout << "after joining, joinable: " << t.joinable() 
              << '\n';
}
// out
before starting, joinable: false
after starting, joinable: true
after joining, joinable: false

可以看到，只要t不去管理线程函数，joinable的值就是false， 下面我们留意一下thread的析构函数，根据代码可以知道，我们在析构线程对象的时候，必须保证joinable=false, 换句话说就是，析构的时候必须保证线程对象内没有任何线程函数，否则会终止程序（是会终止进程）。上面我们说了，join()和detach()函数都可以让线程对象中的线程函数剥离，所以在使用多线程的时候务必要记的。

~thread()
{
    if (joinable()) std::terminate();
}

join

join()函数是做什么的？就是等待线程对象中的线程函数执行完毕，此时会阻塞main线程，一旦执行完了就令joinable就等于false, 正常析构。

detach

不管你线程函数是否执行完，线程对象直接将线程函数剥离出去，joinable就等于false，正常析构。置于析构后，主线程结束了，子线程函数还能不能执行？主要分下面两种情况：

对于windows系统，主线程退出，其他未执行完毕的子线程也会退出，因为主线程退出调用exit()，相当于终止整个进程，其他线程自然而然会终止；
对于linux系统，主线程退出，其他未执行完毕的子线程不会退出，会继续执行，但是这个进程会编程僵尸进程，通过ps -ef查看进程列表，如果有defunct字样的进程，就是僵尸进程。僵尸进程应该被避免。所以，我们应该在主线程退出之前等待其他子线程执行完毕。

在使用detach的时候要注意一个问题：

struct Func
{
	Obj* ptr;
	void operator(){...};
}

void foo()
{
	shared_ptr<Obj> ptr = make_shared<Obj>();
	Func f(ptr);
	thread t(Func);
	t.detach();
}
int main()
{
	foo();
}

可以看到，一旦foo()结束，Obj的资源就会被销毁，那么分离的线程函数就会找不到资源，出现未定义的行为。

RAII管理线程对象

我们知道每个线程对象最后都要调用join()/detach()来处理一下，那么就这和new出来的对象必须用delete删除一样，当程序运行时候的异常或者程序员遗忘处理，都会带来问题，为此请出经典的RAII方法，就在用对象管理资源。
一个简单的代码实现如下：

class thread_guard
{
	thread* t;
public:
	explicit thread_guard(thread* t_):t(t_){};
	~thread_guard()
	{
		if(t->joinable())
		{
			t->join();
		}
	}
	DISABLE_COPY_AND_ASSIGN(thread_guard);
}