C++语法学习笔记四十四：线程传参详解，detach()大坑，成员函数做线程函数

实例代码：

// 
#include <iostream>
#include <vector>
#include <thread>
#include <memory>


using namespace std;

class A
{
public:
	int m_i;
	//类型转换构造函数， 可以把一个int转换成一个类A对象。
	A(int a) :m_i(a) { cout << "[A::A(int a)构造函数执行]" << endl; }
	A(const A&a) :m_i(a.m_i) { cout << "[A::A(const A)拷贝构造函数执行]" << endl; }
	~A(){ cout << "[A::~A()析构函数执行]" << endl; }

	void thread_work(int num) //来个参数
	{
		cout << "[子线程thread_work执行]" << this << "threadid = " << std::this_thread::get_id() << endl;
	}

	void operator()(int num)
	{
		cout << "[子线程()执行]" << this << "threadid = " << std::this_thread::get_id() << endl;
	}

};

void myprint2(const int i, const A& pmybuf)
{
	cout << &pmybuf << endl;  //这里打印的是pmybuf对象的地址
	return;
}



void myprint3(const A& pmybuf)
{
	cout << "子线程myprint3的参数地址是" << &pmybuf <<  "threadid = " << std::this_thread::get_id() << endl; 
	return;
}

//void myprint4(A& pmybuf)
void myprint4(unique_ptr<int> pzn)
{
	
	return;
}


void myprint(const int &i, char* pmybuf)
{
	cout << i << endl;  //分析认为，i并不是mvar的引用，实际是值传递，那么我们认为，
						//即便主线程detach了子线程，那么子线程中用i值应该是安全的；
	cout << pmybuf << endl;  //指针在detach子线程时，绝对会有问题
	return;
}

void myprint1(const int i, const string& pmybuf)
{
	cout << i << endl; 
	cout << pmybuf.c_str() << endl;  //指针在detach子线程时，绝对会有问题
	return;
}

int main()
{

	//一：传递临时对象作为线程参数
	//(1.1) 要避免的陷阱（解释1）
	//(1.2) 要避免的陷阱（解释2）
	//事实1： 只要用临时构造的A类对象作为参数传递给线程，那么就一定能够在主线程执行完毕前把线程函数的第二个参数
	//构建出来，从而确保即便detach()子线程也安全运行。
	//(1.3) 总结
	//(a) 若传递int这种简单类型参数，建议都是值传递。不要用引用，防止节外生枝。
	//(b) 如果传递类对象，避免隐式类型转换。全部都在创建线程这一行就构建出临时对象来，然后在函数参数里，用引用来接；否则系统还会多构造一次对象；浪费。
	//终结结论：
	//(c) 建议不适用detach(), 只使用join();这样就不存在局部变量失效导致线程内存的非法引用问题；

	//二：临时对象作为线程参数继续讲
	//(2.1) 线程id概念： id是个数字，每个线程（不管是主线程还是子线程）实际上都对应着一个数字，而且每个线程对应的这个数字都不同。
		//也就是说，不同的线程，它的线程id(数字)必然是不同；
		//线程id可以用C++标准库里的函数来获取。std::this_thread::get_id()来获取；
	//(2.2) 临时对象构造时机抓捕

	//三：传递类对象、智能指针作为线程参数
	//std::ref 函数；


	//四：用成员函数指针做线程函数  operator()


	int mvar = 1;
	int &mvary = mvar;
	char mybuf[] = "this is a test!";
	thread mytobj(myprint, mvar, mybuf);

	// thread mytobj1(myprint1, mvar, mybuf); //但是mybuf到底是在什么时候转换成string.
							//事实上存在，mybuf都被回收了（main函数执行完了），系统采用mybuf去转string的可能性；
	// thread mytobj2(myprint1, mvar, string(mybuf)); 我们这里直接将mybuf转换成string对象，这是一个可以保证线程中用
							//肯定有效的对象。
	int mysecondpar = 12;
	//thread mytobj3(myprint2, mvar, mysecondpar); //我们是希望mysecondpar转成A类型对象传递给 myprint的第二个参数
	//thread mytobj3(myprint2, mvar, A(mysecondpar)); //在创建线程的同时构造临时对象的方法传递参数是可行的；

	mytobj.join();
	//mytobj.detach(); // 子线程和主线程分别执行
	cout << "I Love China!" << endl;
	

	cout << "主线id是" << std::this_thread::get_id() << endl;
	std::thread mytobj3(myprint3, mvar);
	mytobj3.join();


	A myobj11(10); //生成一个类型对象；
	std::thread mytobj4(myprint3, std::ref(myobj11)); //myobj11将类对象作为线程参数
	mytobj4.join();

	unique_ptr<int> myp(new int(100));
	//std::thread mytobj5(myprint4, myp); //std::move
	//mytobj5.join();

	A myobj33(10); //生成一个类对象
	std::thread mytobj6(&A::thread_work, std::ref(myobj33), 15);
	mytobj6.join();




	system("pause");
}