文章目录
显示
? 优质资源分享 ?
学习路线指引(点击解锁) | 知识定位 | 人群定位 |
---|---|---|
? Python实战微信订餐小程序 ? | 进阶级 | 本课程是python flask+微信小程序的完美结合,从项目搭建到腾讯云部署上线,打造一个全栈订餐系统。 |
?Python量化交易实战? | 入门级 | 手把手带你打造一个易扩展、更安全、效率更高的量化交易系统 |
?线程传参详解
一、传递临时对象作为线程参数
1.1要避免的陷阱
直接看代码:
#include
#include
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
#include
#include
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
using namespace std;
#include
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
#include
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
#include
#include
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
using namespace std;
#include
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都没有问题:
可以看出:会在主线程中拷贝构造一个临时对象传给子线程,由子线程掌控该对象析构释放
转载请注明:xuhss »