多线程03：📕线程传参详解

??线程传参详解

一、传递临时对象作为线程参数

1.1要避免的陷阱

直接看代码：

#include <iostream>#include <thread>using namespace std;void myPrint(const int &i, char* pmybuf){	//如果线程从主线程detach了	// ####1.i不是mvar真正的引用，实际上还是值传递（通过查看地址了解到），即使主线程运行完毕了，子线程用i仍然是安全的，但仍不推荐传递引用 ！！！！    //实际上，使用join传入的也是假引用！	// 推荐改为const int i ！！！	cout << i << endl;	//而指针pmybuf还是指向原来的字符串，所以这么写是不安全的	cout << pmybuf << endl;}int main(){	int mvar = 1;	int& mvary = mvar;	char mybuf[] = "this is a test";	thread myThread(myPrint, mvar, mybuf);//第一个参数是函数名，后两个参数是要传入函数的参数	myThread.join();	//myThread.detach();		cout << "Hello World!" << endl;    return 0;}

1.2要避免的陷阱

看代码：

#include <iostream>#include <thread>#include <string>using namespace std;void myPrint(const int i, const string& pmybuf){	cout << i << endl;	cout << pmybuf << endl;}int main(){	int mvar = 1;	int& mvary = mvar;	char mybuf[] = "this is a test";	//如果detach了，这样仍然是不安全的	//#####2.因为存在主线程运行完了，mybuf被回收了，系统才进行mybuf隐式类型转换成string！！！	//推荐先创建一个临时对象thread myThread(myPrint, mvar, string(mybuf));就绝对安全了，这样就会在主线程中完成string类型构造和参数的拷贝构造！！！（可通过自己构造类，加入线程中来测试一下）；	thread myThread(myPrint, mvar, mybuf);	myThread.join();	//myThread.detach();	cout << "Hello World!" << endl;    return 0;}

1.3总结

• 如果传递int这种简单类型，推荐使用值传递，不要用引用
• 如果传递类对象，避免使用隐式类型转换，全部都是创建线程这一行就创建出临时对象，然后在函数参数里，用引用来接，否则还会创建出一个对象
• 终极结论：建议不使用detach

二、临时对象作为线程参数继续讲

2.1 线程id概念

• id是个数字，每个线程（不管是主线程还是子线程）实际上都对应着一个数字，而且每个线程对应的这个数字都不一样
• 线程id可以用C++标准库里的函数来获取。std::this_thread::get_id()来获取

2.2 临时对象构造时机分析

为什么需要在创建线程的时候就创建临时对象？不能隐式类型转换呢？

①下面我们来看看隐式类型转换：

#include <iostream>using namespace std;#include<thread>class A{public:	int _ma;	A(int ma) : _ma(ma) { cout << "构造函数A()" << " 对象地址：" << this << " 线程PID：" << std::this_thread::get_id() << endl; }	~A() { cout << "析构函数~A()" << " 对象地址：" << this << " 线程PID：" << std::this_thread::get_id() << endl; }	A(const A& a) : _ma(a._ma) { cout << "拷贝构造函数A(const A &a)" << " 对象地址：" << this << " 线程PID：" << std::this_thread::get_id() << endl; }};void myprint2(const A& a){	cout << "对象地址：" << &a << " 子线程PID:" << std::this_thread::get_id() << endl;}int main(){	cout << "线程PID:" << std::this_thread::get_id() << endl;	int temp = 1;	thread mytobj(myprint2, temp);//隐式类型转换		//主线程等子线程	mytobj.join();	//主线程子线程分离	//mytobj.detach();	return 0;}

结果：

可以看出：存在致命问题：竟然是在子线程中创造A类对象，子线程函数中的引用起效果。这说明：如果我们采用detach方式分离了主线程和子线程，一旦主线程比子线程参数隐式转换前结束了，那么子线程将会产生不可预估的结果。

②我们在来看看创建临时对象的方式：

修改上面的thread mytobj(myprint2, temp);，改为：thread mytobj(myprint2, A(temp));

用join和detach方式，都得结果：

可以看出：所有A类对象都在主函数中构造，子线程函数中的引用不起效果。 这说明：在采用detach分离了主线程和子线程，需要传入临时对象。

还有一个问题：如果子线程函数中不用&，会怎么样呢？

会比加引用多了一次子线程内的拷贝构造！浪费内存，为什么呢？因为不同的编译器或平台，对于thread函数处理的方式是不一样，可以用这套代码区Linux看看。（对象优化问题）

三、传递类对象、智能指针作为线程参数

3.1传递类对象作为线程参数

要基于上面的临时对象作为线程参数，子线程里面改对象的值会改变主线程对象的值吗？继续写代码：

#include <iostream>#include <thread>using namespace std;class A {public:	mutable int m_i; //记住！！！：带有mutable关键字,m_i即使实在const中也可以被修改	A(int i) :m_i(i) {}};void myPrint(const A& pmybuf){	pmybuf.m_i = 199;	cout << "子线程myPrint的参数地址是" << &pmybuf << "thread = " << std::this_thread::get_id() << endl;}int main(){	A myObj(10);	//myPrint(const A& pmybuf)中引用不能去掉，如果去掉会多创建一个对象	//const也不能去掉，去掉会出错，可能出现无法接受右值情况（传入临时对象）    	//即使是传递的const引用，但在子线程中还是会调用拷贝构造函数构造一个新的对象，	//因为主线程和子线程中对象不同，所以在子线程中修改m_i的值不会影响到主线程	thread myThread(myPrint, myObj);	myThread.join();	//myThread.detach();	cout << "Hello World!" << endl;    }//如果希望子线程中修改m_i的值影响到主线程，可以用thread myThread(myPrint, std::ref(myObj));这样const就是真的引用了，myPrint定义中的const就可以去掉了，类A定义中的mutable也可以去掉了，因为传入的就是主线程的对象

3.2智能指针作为线程参数

#include <iostream>#include <thread>#include <memory>using namespace std;void myPrint(unique_ptr<int> ptn){	cout << "thread = " << std::this_thread::get_id() << endl;}int main(){	unique_ptr<int> up(new int(10));	//独占式指针只能通过std::move()才可以传递给另一个指针	//传递后up就指向空，新的ptn指向原来的内存	//所以这时就不能用detach了，因为如果用detach，主线程先执行完，new int(10)属于主线程中的泄漏资源，ptn指向的对象就被释放了！	thread myThread(myPrint, std::move(up));	myThread.join();	//myThread.detach();	return 0;}//这块忘记了可以去看看智能指针；

四、用成员函数指针做线程函数

#include <iostream>using namespace std;#include<thread>class A{public:	int _ma;	A(int ma) : _ma(ma) { cout << "构造函数A()" << " 对象地址：" << this << " 线程PID：" << std::this_thread::get_id() << endl; }	~A() { cout << "析构函数~A()" << " 对象地址：" << this << " 线程PID：" << std::this_thread::get_id() << endl; }	A(const A& a) : _ma(a._ma) { cout << "拷贝构造函数A(const A &a)" << " 对象地址：" << this << " 线程PID：" << std::this_thread::get_id() << endl; }		void thread_work(int num) // 子线程任务	{		cout << "子线程执行" << " 子线程PID:" << std::this_thread::get_id() << endl;	}};int main(){	cout << "主线程PID:" << std::this_thread::get_id() << endl;	A myobj(10);	thread mytobj(&A::thread_work, myobj, 15); //传入 成员函数 + 类对象 + 成员函数的参数值；		//主线程等子线程	mytobj.join();	//主线程子线程分离	//mytobj.detach();	return 0;}

join、detach都没有问题：

可以看出:会在主线程中拷贝构造一个临时对象传给子线程，由子线程掌控该对象析构释放