1-1. C++并发（创建线程）

创建线程
案例1：如何创建线程

#include <thread>
void do_some_work();
std::thread my_thread1(do_some_work);//函数对象会复制到新线程的存储空间中，函数对象的执行和调用都在线程的内存空间中进行

class background_task
{
public:
	void operator()() const
	{
		do_something();
		do_something_else();
	}
};
background_task f;
std::thread my_thread2(f);//可调用对象f，必须对（）符号进行重载
std::thread my_thread3((background_task()));//std::thread my_thread(background_task())不可用，使用临时变量该语句会被编译器判定为函数声明
std::thread my_thread4{background_task()};//新的初始化语法

案列2：线程的加入、分离
一旦开始了线程，你需要显式地决定是要等待它完成，还是让它自行运行。如果你在std::thread对象被销毁之前还未决定，那么你的程序会被终止(std::thread的析构函数调用std::terminate终端线程，这将会造成exception)。如果选择等待线程，则应该将join命令放到合适的位置，因为在等待线程期限，主线程是不会做其他事情的。如果选择分析线程，则应该注意子线程使用的资源（例如引用和指针）是否在主线程结束后还是有效，举例请看案例3。

#include <iostream>
#include <thread>
void do_some_work()

int main()
{
	cout<<"run do_some_work"<<endl;
	std::thread my_thread(do_some_work);//创建线程
	... //应该在join之前进行一些其他的工作防止浪费线程资源
	my_thread.join();//加入线程，主线程会等待子线程结束
	//my_thread.detach()  分离线程，主线程不会等待子线程结束
	return 0;
}

案例3：线程分离需要注意的情况
在下面的例子中，当主线程退出时，和my_thread相关联的线程可能仍然在运行中，但是当线程调用do_something(i)的时候，就会访问为销毁的i变量，这将会造成异常。而另外一种常见情况就是被分离的线程使用了被释放的指针，从而造成错误。常见的处理方式就是将数据复制到该线程中而不是共享数据。

#include <iostream>
#include <stream>
struct func
{
	int& i;
	func(int& i_):i(i_){}
	void operator()()
	{
		for(unsigned j=0; j<10000; ++j)
		{
			do_something(i);
		}
	}
}
int main()
{
	int local_state = 0;
	func my_func(local_state);
	std::thread my_thread(my_func);
	my_thread.detach();
}

案例4：异常情况下的等待
在前面我们已经讲过了，开始线程后需要显式地加入或者分析线程，避免由此造成的异常。另外，当主线程中出现异常时也要对子线程进行管理。但是这样的结构很啰嗦，因此可以用更简洁的方式，资源获取即初始化（RAII）

#include <iostream>
#include <thread>
struct func;
void f()
{
	int local_state=0;
	func my_func(local_state);
	std::thread my_thread(my_func);
	try
	{
		do_something();
	}
	catch(...)
	{
		my_thread.join();  //异常情况下的join
		throw;
	}
	my_thread.join(); //正常情况下的join
}

案例5：资源获取即初始化（RAII）
将线程的控制放在一个类里面，从而可以保险的进行操作防止join操作的遗漏。

#include <iostream>
#include <thread>
class thread_guard
{
	std::thread& t;
public:
	explicit thread_guard(std::thread& t_):
		t(t_){}
	~thread_guard()
	{
		if(t.joinable())
		{
			t.join();
		}
	}
	thread_guard(thread_guard const&)=delete;//确保编译器不会自动生成拷贝构造函数和赋值运算符重载
	thread_guard& operator=(thread_guard const&)=delete;
};
struct func;
int main()
{
	int local_state=0;
	func my_func(local_state);
	std::thread t(my_func);
	thread_guard g(t);
	do_something();
}

*本文大部分内容整理自《C++并发编程实战》