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

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

示例:

#include <iostream>
#include <thread>

void myprint(const int &i, char *pmybuf) {
	std::cout << "i = " << i << std::endl;
    std::cout << "pmybuf = " << pmybuf << std::endl;
	return;
}

int main()
{
	int my = 1;
	int &may = my;
	char buf[] = "I love china";

	std::thread obj(myprint, my, buf);
	obj.join();
	std::cout << "main thread finished!!" << std::endl;
	return 0;
}

1. 要避免的陷阱

如果线程从主线程detach了，i不是my真正的引用，实际上值传递(复制了一份)，即使主线程运行完毕了，子线程用i仍然是安全的，但仍不建议传递引用，推荐改为const int i。 如果是直接使用函数的话，这里i的地址和传入参数的地址一致。
pmybuf 还是指向原来的字符串，所以这么写不安全，在detach时绝对会有问题。
例: 参数 my

0x00eff940 {1}
0x00eff940 {1}
直接传入函数
0x00eff940 {1}
使用线程
0x01010a9c {1}

参数buf

0x00b7f750 "I love china"
函数传入
0x00b7f750 "I love china"
&pmybuf
0x00b7f65c {0x00b7f750 "I love china"}
线程
0x00b7f750 "I love china"
&pmybuf
0x00cef99c {0x00b7f750 "I love china"}

2. 要避免的陷阱2

buf到底在什么时候转换成string，事实上存在,mybuf都被回收了（main函数都执行完了），系统才用mybuf去转string的可能性。
推荐先创建一个临时对象thread myThread(myPrint, mvar, string(mybuf));就绝对安全了。。。。使用该方法（创建临时对象的方法）调用了拷贝构造函数，生成了一个临时对象。

#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
	//推荐先创建一个临时对象thread myThread(myPrint, mvar, string(mybuf));就绝对安全了。。。。
	thread myThread(myPrint, mvar, mybuf);
	myThread.join();
	//myThread.detach();

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

事实1: 只要用临时构造的A类对象作为参数传递给线程。那么就一定能够在主线程执行完毕前把线程函数的第二个参数构建出来，从而确保即便detach子线程也安全运行。

3. 总结

若传递int这种简单类型参数，建议都是值传递，不要用引用；
如果传递类对象，避免隐式类型转换，全部都在创建线程这一行就构建出临时对象，然后在函数参数里，用引用来接，否则还会创建出一个对象；
建议不使用detach()，只使用join():这样就不存在局部变量失效导致线程对内存的非法引用问题；

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

1. 线程id概念

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

2. 临时对象构造时机捕获 如果使用隐式类型转换:

std::thread myobj(myprint,mvar);

比较致命的问题: 在子线程中构造A类的对象

如果使用临时对象的方法

std::thread myobj(myprint,A(mvar));

用了临时对象后，所有的A类对象都在main()函数中就已经构建完毕了

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

#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;
}

myPrint(const A& pmybuf)中引用不能去掉，如果去掉会多创建一个对象
const也不能去掉，去掉会出错
即使是传递的const引用，但在子线程中还是会调用拷贝构造函数构造一个新的对象，所以在子线程中修改m_i的值不会影响到主线程
如果希望子线程中修改m_i的值影响到主线程，可以用thread myThread(myPrint, std::ref(myObj));
这样const就是真的引用了，myPrint定义中的const就可以去掉了，类A定义中的mutable也可以去掉了 std::ref()可以将真引用传入函数

#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));//由于这里使用move所以当运行到这里后 之前的up里值不存在，子线程函数执行完之后才会被释放
	myThread.join();
	//myThread.detach();

	return 0;
}

独占式指针只能通过std::move()才可以传递给另一个指针
传递后up就指向空，新的ptn指向原来的内存
所以这时就不能用detach了，因为如果主线程先执行完，ptn指向的对象就被释放了

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