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

最新推荐文章于 2023-11-14 18:59:38 发布
最新推荐文章于 2023-11-14 18:59:38 发布
阅读量359 收藏
点赞数
分类专栏： C++多线程学习 文章标签： 学习 经验分享 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EthanChenJia/article/details/130180484
版权

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

3.1.1 要避免的陷阱–解释1

#include <iostream>
#include <thread>

using namespace std;

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

int main()
{
	int mvar = 1;
	int &mvary = mvar;
	char mybuf[] = "this is a test!";

	thread mytobj(myprint, mvar, mybuf);
	//mytobj.join();
	mytobj.detach();

	cout << "主线程执行结束！！！" << endl;

	return 0;
}

1、使用detach时，会不会因为主线程结束了就销毁了mvar变量，导致子线程访问不安全呢？
调试时，shift+f9查看变量的地址发现mvar的地址和i的地址不一样，分析认为i并不是mvar的引用，实际是值传递，那么我们认为，即便主线程detach了子线程，那么子线程中使用i值也是安全的。但是也不推荐使用引用，还是使用值传递
在这里插入图片描述
2、那么pmybuf是不是安全的呢？
查看地址发现地址一样，主线程执行完了，mybuf 指向的内存被系统回收，子线程再使用这个指针是不安全的，因此在detach子线程时，指针绝对会有问题
mybuf = 0x010ff9d0 "烫烫烫烫烫烫烫烫
pmybuf = 0x010ff9d0 “this is a test!”

3.1.2 要避免的陷阱–解释2

#include <iostream>
#include <thread>

using namespace std;

void myprint(const int i, const string& pmybuf)
{
	cout << i << endl; 
	cout << pmybuf.c_str() << endl;
	return;
}

int main()
{
	int mvar = 1;
	int &mvary = mvar;
	char mybuf[] = "this is a test!";

	thread mytobj(myprint, mvar, mybuf);
	//mytobj.join();
	mytobj.detach();

	cout << "主线程执行结束！！！" << endl;

	return 0;
}

1、那么使用const string& pmybuf去接受字符串数组安全吗？
在这里插入图片描述
内存地址并不同，看是好像安全，但是真的安全吗？需要清楚mybuf 是在什么时候被转化为string的，事实上存在mybuf都被回收了(main函数执行完了），系统才用mybuf去转string的可能性，那么如何修改呢？
我们直接将mybuf转换成string对象，这是一个可以保证在线程中用肯定有效的对象

#include <iostream>
#include <thread>

using namespace std;

void myprint(const int i, const string& pmybuf)
{
	cout << i << endl; 
	cout << pmybuf.c_str() << endl;
	return;
}

int main()
{
	int mvar = 1;
	int &mvary = mvar;
	char mybuf[] = "this is a test!";

	thread mytobj(myprint, mvar, string(mybuf));
	//mytobj.join();
	mytobj.detach();

	cout << "主线程执行结束！！！" << endl;

	return 0;
}

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

3.1.3 总结

1、若传递int这种简单类型参数，建议都是值传递,不要用引用。防止节外生枝。
2、如果传递类对象，避免隐式类型转换。全部都在创建线程这一行就构建出临时对象来，然后在函数参数里，用引用来接，否则系统还会构造一次对象，浪费
//终极结论:
3、建议不使用detach()，只使用join()， 这样就不存在局部变量失效导致线程对内存的非法引用问题

3.2 临时对象作为线程参数（续）

3.2.1 线程id概念

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

#include <iostream>
#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 << "threadid = " << std::this_thread::get_id() << endl; }
	A(const A& a) :m_i(a.m_i) { cout << "[A::A(const A)拷贝构造函数执行]" << this << "threadid = " << std::this_thread::get_id() << endl; }
	~A() { cout << "[A::~A()析构函数执行]" << this << "threadid = " << std::this_thread::get_id() << endl; }
};


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

int main()
{
	cout << "主线程id是" << std::this_thread::get_id() << endl;
	int mvar = 1;

	thread mytobj(myprint, mvar);
	mytobj.join();

	return 0;
}

在这里插入图片描述
使用临时对象

#include <iostream>
#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 << "threadid = " << std::this_thread::get_id() << endl; }
	A(const A& a) :m_i(a.m_i) { cout << "[A::A(const A)拷贝构造函数执行]" << this << "threadid = " << std::this_thread::get_id() << endl; }
	~A() { cout << "[A::~A()析构函数执行]" << this << "threadid = " << std::this_thread::get_id() << endl; }
};


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

int main()
{
	cout << "主线程id是" << std::this_thread::get_id() << endl;
	int mvar = 1;

	thread mytobj(myprint, A(mvar));
	mytobj.join();

	return 0;
}

用了临时对象后，所有的A类对象都在main()函数中就已经构建完毕了
在这里插入图片描述
此时使用mytobj.detach()就不会有问题
注意：void myprint(const A& pmybuf)要使用引用，不用引用会调用一个构造函数，两个拷贝构造函数，造成浪费，此外第二个拷贝构造还是在主线程中执行的

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

#include <iostream>
#include <thread>

using namespace std;

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

void myprint(const A& pmybuf)
{
	pmybuf.m_i = 199;   //我们修改该值不会影响到main函数
	cout << "子线程myprint的参数地址是" << &pmybuf << "threadid = " <<std::this_thread::get_id() << endl;
}

int main()
{
	cout << "主线程id是" << std::this_thread::get_id() << endl;

	A myobj(10);   //生成一个类对象

	thread mytobj(myprint, myobj);  //myobj将类对象作为一个线程参数
	mytobj.join();

	return 0;
}

shift + f9
在这里插入图片描述
通过分析发现，这都不是同一个地址，虽然是引用，但是在main函数传递的myobj并没有在线程中被修改，这种写法会被拷贝一份

但是用引用，就应该被修改，这个要怎么解决呢？
使用std::ref

#include <iostream>
#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 << "threadid = " << std::this_thread::get_id() << endl; }
	A(const A& a) :m_i(a.m_i) { cout << "[A::A(const A)拷贝构造函数执行]" << this << "threadid = " << std::this_thread::get_id() << endl; }
	~A() { cout << "[A::~A()析构函数执行]" << this << "threadid = " << std::this_thread::get_id() << endl; }
};

void myprint(A& pmybuf)
{
	pmybuf.m_i = 199;   //我们修改该值不会影响到main函数
	cout << "子线程myprint的参数地址是" << &pmybuf << "threadid = " <<std::this_thread::get_id() << endl;
}

int main()
{
	cout << "主线程id是" << std::this_thread::get_id() << endl;

	A myobj(10);   //生成一个类对象

	std::thread mytobj(myprint, std::ref(myobj));  //myobj将类对象作为一个线程参数
	mytobj.join();

	return 0;
}

在这里插入图片描述
此时地址一样，可以实现使用引用，在main函数传递的myobj可以在线程中被修改，这种写法不会再被拷贝一份

如果是智能指针该怎么传呢？
要使用std::move

#include <iostream>
#include <thread>

using namespace std;

void myprint(unique_ptr<int> pzn)
{
	return 0;
}

int main()
{
	cout << "主线程id是" << std::this_thread::get_id() << endl;

	unique_ptr<int> myp(new int(100));

	std::thread mytobj(myprint, std::move(myp));
	mytobj.join();

	return 0;
}

3.4 用成员函数指针作线程函数

#include <iostream>
#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 << "threadid = " << std::this_thread::get_id() << endl; }
	A(const A& a) :m_i(a.m_i) { cout << "[A::A(const A)拷贝构造函数执行]" << this << "threadid = " << std::this_thread::get_id() << endl; }
	~A() { cout << "[A::~A()析构函数执行]" << this << "threadid = " << std::this_thread::get_id() << endl; }

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

int main()
{
	cout << "主线程id是" << std::this_thread::get_id() << endl;

	A myobj(10);   //生成一个类对象

	std::thread mytobj(&A::thread_work, myobj, 15);

	mytobj.join();

	return 0;
}

类对象做线程函数

#include <iostream>
#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 << "threadid = " << std::this_thread::get_id() << endl; }
	A(const A& a) :m_i(a.m_i) { cout << "[A::A(const A)拷贝构造函数执行]" << this << "threadid = " << std::this_thread::get_id() << endl; }
	~A() { cout << "[A::~A()析构函数执行]" << this << "threadid = " << std::this_thread::get_id() << 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;
	}
};

int main()
{
	cout << "主线程id是" << std::this_thread::get_id() << endl;

	A myobj(10);   //生成一个类对象
 
	std::thread mytobj(myobj, 15);

	mytobj.join();

	return 0;
}

如果加std::ref就不会调用拷贝构造函数，但是此时要注意不要使用detach了

ChenEthan_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11多线程join()和detach()的理解
m0_74822999的博客
10-09 1323
每一个程序至少拥有一个线程，那就是执行main()函数的主线程，而多线程则是出现两个或两个以上的线程并行运行，即主线程和子线程在同一时间段同时运行。主线程先运行结束子线程先运行结束主子线程同时结束在一些情况下需要在子线程结束后主线程才能结束，而一些情况则不需要等待，但需注意一点，并不是主线程结束了其他子线程就立即停止，其他子线程会进入后台运行。
C++ 线程函数是类的成员函数
05-09
3. **线程函数作为成员函数**：将线程函数定义为类的成员，可以方便地访问类的私有数据，无需通过额外的同步机制（如锁）来保护数据，因为线程函数和数据在同一作用域内，天然具备了访问权限。 二、创建线程成员...
C++多线程detach函数使用
音视频图像相关
12-30 1万+
多线程中detach的使用
C++ 多线程detach()操作的坑以及传参
热门推荐
jinking01的专栏
09-16 1万+
detach()的作用是将子线程和主线程的关联分离，也就是说detach()后子线程在后台独立继续运行，主线程无法再取得子线程的控制权，即使主线程结束，子线程未执行也不会结束。当主线程结束时，由运行时库负责清理与子线程相关的资源。实际应用如让一个文字处理应用同时编辑多个文档，让每个文档处理窗口拥有自己的线程，每个线程运行同样的代码，并隔离不同窗口处理的数据。 1 #include <thread> 2 #include <iostream> 3 4 using name
线程传参详解、detach()大坑、成员函数做线程函数
weixin_42136255的博客
05-12 702
#include <iostream> #include <thread> using namespace std; void myprint(const int& i,char* pmybuf) { printf("&i=%p\n",&i); // i 虽然是引用，但是是值拷贝 cout<<i<<endl; cout<<pmybuf<<endl; //pmybuf 和主线程的my.
线程传参详解，detach()大坑，成员函数做线程函数
Scarlett的博客
02-20 1437
一、传递临时对象作为线程参数 1.1 要避免的陷阱1 #include<iostream> #include<thread> using namespace std; void myprint(const int &i,char* pmybuf) { cout << i << endl; cout << pmybuf << endl; return; } int main() { int mvar = 6; in
Linux多线程环境下 关于进程线程终止函数总结
09-15
在Linux多线程环境中，理解和掌握进程线程终止的相关函数是至关重要的。这些函数用于控制线程的行为，确保程序的正常运行和资源的正确释放。以下是关于Linux多线程环境下进程线程终止函数的详细总结： 1. **pthread...
类成员函数创建线程源码
08-22
本主题将深入探讨如何在类的成员函数中创建线程，即“类内线程”。这允许我们更好地封装和管理线程相关的逻辑，使代码更易于理解和维护。 首先，我们需要引入C++11标准库中的`<thread>`头文件，它提供了对线程的...
简单了解C语言中主线程退出对子线程的影响
12-23
尽管在编程时我们可能称创建的第一个线程为主线程，但在Linux内核中并没有这样的区分，所有线程都是平等的。 **结论** 在C语言的多线程编程中，主线程的退出并不意味着子线程的退出，除非整个进程结束。子线程的...
深入分析父子线程、进程终止顺序不同产生的结果
01-20
Linux下编程，线程、进程退出顺序问题纷纷扰扰，如果父进程/线程先于子进程/线程终止，系统会做什么处理呢？反之，如果子进程/线程先于父进程/线程终止，系统又会做什么处理呢？下面是我个人平时在笔记上做的一些...
java detach_线程 （detach的作用）
weixin_34663036的博客
02-12 880
线程状态在一个线程的生存期内，可以在多种状态之间转换。不同操作系统可以实现不同的线程模型，定义许多不同的线程状态，每个状态还可以包含多个子状态。但大体说来，如下几种状态是通用的：就绪：参与调度，等待被执行。一旦被调度选中，立即开始执行。运行：占用CPU，正在运行中。休眠：暂不参与调度，等待特定事件发生。中止：已经运行完毕，等待回收线程资源(要注意，这个很容易误解，后面解释)。线程环境线程存在于进程...
C++11并发与多线程学习笔记3(P5)——线程传参、detach()易错点、成员函数做线程函数
Doggerlas的博客
03-04 676
本笔记内容完全来源于B站同名课程：C++11并发与多线程​。侵权必删！
C++11多线程第三篇：线程传参详解，detach()大坑，成员函数做线程参数
森明帮大于黑虎帮的博客
11-13 3571
C++11多线程第三篇：线程传参详解，detach()大坑，成员函数做线程参数
detach，主线程终止后子线程会结束吗
a0408152的博客
02-17 4913
研究detach的坑和进程的退出机制
【C++】join ()和detach ()函数详解和示例
不定时分享，互相学习，共同进步
11-14 1624
简单的来说，join ()方法建立的线程具有阻碍作用，该线程不结束，另一些函数就无法运行。detach ()方法建立的线程，可以和另一些函数同时进行。下面以示例进行详细说明，以帮助大家理解和使用。
多线程中的detach
weixin_30268921的博客
08-18 385
从 thread 对象分离执行的线程，允许执行独立地持续。一旦线程退出，则释放所有分配的资源。(就是两个线程彼此相互独立) 调用detach后，*this不再占有任何线程。 #include <iostream> #include <chrono> #include <thread> void independentThrea...
线程 （detach的作用）
每天都要进步！
09-02 3874
线程 （detach的作用）线程状态在一个线程的生存期内，可以在多种状态之间转换。不同操作系统可以实现不同的线程模型，定义许多不同的线程状态，每个状态还可以包含多个子状态。但大体说来，如下几种状态是通用的：       就绪：参与调度，等待被执行。一旦被调度选中，立即开始执行。       运行：占用CPU，正在运行中。       休眠：暂不参与调度，等待特定事件发生。       中止：已经运行完毕，等待回收线程资源（要注意，这个很容易误解，后面解释）。线程环境线程存在于进程之中。进程内所有全局资源对于
C++11多线程第二篇：线程启动、结束、创建线程的多个方法：join、detach
森明帮大于黑虎帮的博客
11-05 2521
C++11多线程第二篇：线程启动、结束、创建线程的多个方法：join、detach
类中创建线程使用成员函数
最新发布
06-26
在类中创建线程通常涉及使用C++标准库中的`std::thread`，以及通过成员函数来封装线程操作。以下是一个简单的步骤： 1. **定义成员函数**：首先，你需要在类中定义一个或多个成员函数，这些函数将作为线程执行的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值