C++11并发与多线程笔记（3） 线程传参详解，detach()大坑，成员函数做线程函数

第三节 线程传参详解，detach()大坑，成员函数做线程函数

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

1.1要避免的陷阱1：

#include <iostream>
#include <thread>
using namespace std;

void myPrint(const int &i, char* pmybuf)
{
	//如果线程从主线程detach了
	//i不是mvar真正的引用，实际上值传递，即使主线程运行完毕了，子线程用i仍然是安全的，但仍不推荐传递引用
	//推荐改为const int i  直接传值
	cout << i << endl;
	//pmybuf还是指向原来的字符串，所以这么写是不安全的（当main运行完mybuf就被收回，子线程的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;
}

1.2要避免的陷阱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了，这样仍然是不安全的
	//因为存在主线程运行完了，mybuf被回收了，系统采用mybuf隐式类型转换成string（这个隐式类型转换可能是在main结束之后才进行，但是mybuf已经被收回了）
	//推荐先创建一个临时对象thread myThread(myPrint, mvar, string(mybuf));就绝对安全了（因为这个临时对象是在主线程中进行的，所以肯定是在main函数结束之前进行）
	thread myThread(myPrint, mvar, mybuf);
	myThread.join();
	//myThread.detach();
	cout << "Hello World!" << endl;
}

1.3总结

• 如果传递int这种简单类型，推荐使用值传递，不要用引用
• 如果传递类对象，避免使用隐式类型转换，全部都是创建线程这一行就创建出临时对象，然后在函数参数里，用引用来接，否则系统还会多构造一次拷贝构造函数，浪费
• 终极结论：建议不使用detach，只用join，这样就不存在局部变量失效导致线程对内存的非法引用问题

其他：
shift+F9 快速监视 &变量 能够查看某变量的地址 （在调试状态下）

数据类型前加 mutable 能够在const 的情况下 修改变量值

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

2.1线程 id概念

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

#include<iostream>
#include<vector>
#include<map>
#include<string>
#include<thread>

using namespace std;

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

//线程的初始函数不推荐传引用，更不能传指针
//void myprint(const int &i, char *pmybuf)
//{
//	cout << i << endl;//分析认为（shift+f9快速监视变量地址，看是否被主线程回收），i并不是mvar的引用，实际是值传递，那么我们认为，即便主线程detach了子线程，那么子线程中用i值仍然是安全的
//	cout << pmybuf << endl;//指针在detach子线程时，绝对会有问题
//	return;
//}
//修改：
//void myprint(const int i, const string &pmybuf)//从char到string必然有隐式类型转换，相当于复制了一份给子线程
//{
//	cout << i << endl;//分析认为（shift+f9快速监视变量地址，看是否被主线程回收），i并不是mvar的引用，实际是值传递，那么我们认为，即便主线程detach了子线程，那么子线程中用i值仍然是安全的
//	cout << pmybuf << endl;//指针在detach子线程时，绝对会有问题
//	return;
//}
void myprint(const int i, const A &pmybuf)
{
	cout << &pmybuf << endl;//这里打印的是pmybuf对象的地址
	return;
}

int main()
{
	//一、传递临时对象作为线程参数
	//(1,1)要避免的陷阱（解释1）
	//(1,2)要避免的陷阱（解释2）
	//int mvar = 1;
	//int &mvary = mvar;
	//char mybuf[] = "this is a test";
	//thread mytobj(myprint, mvar, mybuf);//但是mybuf到底是在什么时候转换成string的，如果在main结束了才转那就尴尬了
	//事实上存在，mybuf都被回收了（main执行完了）系统采用mybuf去转string的可能性
	//这样修改：
	//thread mytobj(myprint, mvar, string(mybuf));//这里直接将mybuf转成string临时对象，这是一个可以保证在线程中肯定有效的变量
	//mytobj.join();
	int mvar = 1;
	int mysecondpar = 12;
	//thread mytobj(myprint, mvar, mysecondpar);//我们是希望mysecondpar转成A类型对象传递给myprin的第二个参数,这是效仿char转string的情形
	thread mytobj(myprint, mvar, A(mysecondpar));//用类A构造一个临时对象,就能保证在main结束之前将mysecondpar拷贝
	//没想到还构造A的拷贝构造该函数了，说明虽然const A &pmybuf是用引用接的，但是很粗暴的拷贝了一份
	//mytobj.join();
	mytobj.detach();//子线程和主线程分离，这时就要注意一些坑了

	//cout << "i love china" << endl;

	return 0;
}

//在创建线程的同时构造临时对象的方法传递参数是可行的

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

3.1
std::ref 函数 传给线程的才是真实的引用 能够把线程中的值返回来 不然就算线程是用引用接的 其实也是拷贝了一份（可能处于安全考虑） std::ref(myobj) == &myobj

用智能指针作线程参数，要用std::move 这样才能将线程函数中的指针指向主线程定义的智能指针，但是要用join，不然会有问题

#include <iostream>
#include <thread>
using namespace std;

class A {
public:
	mutable int m_i; //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的值不会影响到主线程
	//如果希望子线程中修改m_i的值影响到主线程，可以用thread myThread(myPrint, std::ref(myObj));
	//这样const就是真的引用了，myPrint定义中的const就可以去掉了，类A定义中的mutable也可以去掉了
	thread myThread(myPrint, myObj);
	myThread.join();
	//myThread.detach();

	cout << "Hello World!" << endl;
}

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了，因为如果主线程先执行完，ptn指向的对象就被释放了
	thread myThread(myPrint, std::move(up));
	myThread.join();
	//myThread.detach();

	return 0;
}

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

放在了2.2

//举例
std::thread myobj(&A::thread_work, std::ref(myobj), 15); 
//thread_work是类A的成员函数，myobj是类A的对象，15是成员函数的参数