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

最新推荐文章于 2024-07-16 10:12:41 发布
最新推荐文章于 2024-07-16 10:12:41 发布
阅读量1.4k 收藏 4
点赞数 1
分类专栏： C++11并发与多线程 文章标签： c++ 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Scarlett2025/article/details/123011038
版权
一、传递临时对象作为线程参数
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;
	int &myvar = mvar;
	char mybuf[] = "MD-DynamicDebug";

	thread myobj(myprint,mvar,mybuf);
	myobj.join();

	cout << "主线程运行结束..." << endl;

	system("pause");
	return 0;
}

在这里插入图片描述
如果以detach方式创建线程

  • mvar是否安全？
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    分析认为：i并不是mvar的引用，实际是值传递。那么我们认为，即便主线程detach子线程，那么子线程中用i值仍然是安全的
1.2 要避免的陷阱2
  • mybuf是否安全
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述
指针在detach子线程时，绝对会有问题
考虑传字符串解决方法解决

#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 = 6;
	int &myvar = mvar;
	char mybuf[] = "MD-DynamicDebug";

	thread myobj(myprint, mvar, mybuf);
	myobj.join();

	cout << "主线程运行结束..." << endl;

	system("pause");
	return 0;
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述但是mybuf到底是在什么时候转换成string的
事实上存在mybuf被回收了（main函数执行完了），系统采用mybuf去转string的可能性
直接将mybuf转换成string对象，这是一个可以保证在线程中用肯定有效的对象

#include<iostream>
#include<thread>

using namespace std;

class A {
public:
	//类型转换构造函数，可以把一个int转换成一个类对象
	A(int i) :m_i(i) {
		cout << "构造函数执行。。" << endl;
	}
	A(const A&a) :m_i(a.m_i) {
		cout << "拷贝函数执行。。" << endl;
	}
	~A() {
		cout << "析构函数执行。。" << endl;
	}

private:
	int m_i;
};

void myprint4(const int i, const A &pmybuf) {
	cout << &pmybuf << endl;//这里打印的是pmybuf对象的
	return;
}

int main() {
	int mvar = 1;
	int mysecondpar = 12;

	thread myobj4(myprint4, mvar, mysecondpar);//我们希望mysecondpar转成A类型对象传递给myprint的第二个参数
	myobj4.join();

	cout << "主线程运行结束..." << endl;

	system("pause");
	return 0;
}

在这里插入图片描述

#include<iostream>
#include<thread>

using namespace std;

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

private:
	int m_i;
};

void myprint4(const int i, const A &pmybuf) {
	cout << &pmybuf << endl;//这里打印的是pmybuf对象的
	return;
}

int main() {
	int mvar = 1;
	int mysecondpar = 12;


	thread myobj4(myprint4, mvar, A(mysecondpar));
	myobj4.detach();

	cout << "主线程运行结束..." << endl;

	system("pause");
	return 0;
}

在这里插入图片描述
在创建线程的同时构造临时对象的方法传递参数是可行的
**事实1：**只要用临时构造的A类对象作为参数传递给线程，那么就一定能够在主线程执行完毕前把线程函数的第二个参数构建出来，从而确保即便detach，程序也能安全运行

1.3 总结

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

二、临时对象作为线程参数继续讲
2.1 线程id概念

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

2.2 临时对象构造时机捕获
#include<iostream>
#include<thread>

using namespace std;

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

private:
	int m_i;
};

void myprint4(const int i, const A &pmybuf) {
	cout << "&pmybuf=" << &pmybuf << endl;//这里打印的是pmybuf对象的
	return;
}

int main() {
	int mvar = 1;
	int mysecondpar = 12;

	//thread myobj4(myprint4, mvar, mysecondpar);//我们希望mysecondpar转成A类型对象传递给myprint的第二个参数
	thread myobj4(myprint4, mvar, A(mysecondpar));
	myobj4.detach();

	cout << "主线程运行结束..." << endl;

	system("pause");
	return 0;
}

在这里插入图片描述

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

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

private:
	int m_i;
};

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

int main() {
	cout << "主线程ID：" << this_thread::get_id() << endl;

	int mvar = 6;

	thread myobj6(myprint6, mvar);
	myobj6.join();

	system("pause");
	return 0;
}

在这里插入图片描述

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

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

private:
	int m_i;
};

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

int main() {
	cout << "主线程ID：" << this_thread::get_id() << endl;

	int mvar = 6;

	thread myobj6(myprint6, A(mvar));
	myobj6.join();

	system("pause");
	return 0;
}

在这里插入图片描述

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

在子线程中修改m_i的值不会影响到主线程？

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

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

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

int main() {
	cout << "主线程ID：" << this_thread::get_id() << endl;

	A myobj7(19);//生成一个类对象
	thread mythread(myprint7, myobj7);//myobj7将类对象作为线程参数
	mythread.join();

	system("pause");
	return 0;
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
主线程值的地址和子线程中值的地址不同，所以在子线程中修改m_i的值不会影响到主线程

  • 希望子线程中修改m_i的值影响到主线程
#include<iostream>
#include<thread>
using namespace std;

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

	int m_i;//可以去掉mutable
};

//void myprint8(const A &pmybuf) {
void myprint8(A &pmybuf) {//const可以去掉
	pmybuf.m_i = 23;//我们修改该值，不会影响到main函数
	cout << "子线程myprint6的参数地址是:" << &pmybuf <<
		"threadID=" << this_thread::get_id() << endl;
}

int main() {
	cout << "主线程ID：" << this_thread::get_id() << endl;

	A myobj7(19);//生成一个类对象
	thread mythread(myprint8, ref(myobj7));//希望子线程中修改m_i的值影响到主线程
	mythread.join();

	system("pause");
	return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

void myprint9(unique_ptr<int> pzn) {
	
}

int main() {
	cout << "主线程ID：" << this_thread::get_id() << endl;

	unique_ptr<int>myp(new int(100));
	thread mythread(myprint9, move(myp));//希望子线程中修改m_i的值影响到主线程
	mythread.join();//不可以用detach

	system("pause");
	return 0;
}

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

参数智能指针和原来的智能指针指向的是同一块内存

用成员函数指针做线程参数
#include<iostream>
#include<thread>
using namespace std;

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

	void thread_work(int num) {
		cout << "子线程thread_work执行。。。" << this << " threadID:" << this_thread::get_id() << endl;
	}

	int m_i;
};


int main() {
	cout << "主线程ID：" << this_thread::get_id() << endl;

	A myobj7(19);//生成一个类对象
	thread mythread(&A::thread_work, myobj7, 25);
	/*
	thread mythread(&A::thread_work,ref(myobj7),25);//&myobj7==ref(myobj7)
	thread mythread(&A::thread_work, &myobj7, 25);这两种情形用detach都不安全，没有复制出新对象
	*/
	mythread.join();

	system("pause");
	return 0;
}

在这里插入图片描述

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

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

	void thread_work(int num) {
		cout << "子线程thread_work执行。。。" << this << " threadID:" << this_thread::get_id() << endl;
	}

	void operator()(int num) {
		cout << "子线程()执行。。。" << this << " threadID:" << this_thread::get_id() << endl;
	}

	int m_i;
};


int main() {
	cout << "主线程ID：" << this_thread::get_id() << endl;

	A myobj7(19);//生成一个类对象
	thread mythread(myobj7, 25);//可以用detach，调用了拷贝构造函数
	//thread mythread(ref(myobj7), 25);//不调用拷贝构造函数
	//thread mythread(&myobj7, 25);//报错

	mythread.join();

	system("pause");
	return 0;
}

在这里插入图片描述

Scarlett2025
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 线程函数是类的成员函数
05-09
3. **线程函数作为成员函数**：将线程函数定义为类的成员，可以方便地访问类的私有数据，无需通过额外的同步机制（如锁）来保护数据，因为线程函数和数据在同一作用域内，天然具备了访问权限。 二、创建线程成员...
类成员函数创建线程源码
08-22
- 类成员线程函数应尽可能避免访问非静态成员变量，因为这可能导致数据竞争和线程安全问题。如果需要共享数据，考虑使用互斥锁（`std::mutex`）、条件变量（`std::condition_variable`）或其他同步机制。 - 记住，...
（C++11/14/17学习笔记）：线程传参详解，detach()陷阱，成员函数做线程函数
baidu_41388533的博客
12-08 644
线程传参详解，detach()陷阱，成员函数做线程函数 传递临时对象作为线程参数 【引例】 #include <iostream> #include <string> #include <thread> using namespace std; void myprint(const int& i, char* pmybuf ) { cout << i << endl; cout << pmybu...
C++多线程：线程的创建、join、detach、joinable方法（二）
weixin_43808717的博客
03-29 1797
线程的创建方式也可以通过传入一个类对象，并在类内部对函数运算符()进行重载，使用detach或者join都行。public:std::cout
C++ 多线程detach()操作的坑以及传参
热门推荐
jinking01的专栏
09-16 1万+
detach()的作用是将子线程和主线程的关联分离，也就是说detach()后子线程在后台独立继续运行，主线程无法再取得子线程的控制权，即使主线程结束，子线程未执行也不会结束。当主线程结束时，由运行时库负责清理与子线程相关的资源。实际应用如让一个文字处理应用同时编辑多个文档，让每个文档处理窗口拥有自己的线程，每个线程运行同样的代码，并隔离不同窗口处理的数据。 1 #include <thread> 2 #include <iostream> 3 4 using name
C++11thread之detach()与join()的函数对比
量化开发技术点集锦
02-27 1万+
在声明一个std::thread对象之后，都可以使用detach和join函数来启动被调线程，区别在于两者是否阻塞主调线程。 （1）当使用join()函数时，主调线程阻塞，等待被调线程终止，然后主调线程回收被调线程资源，并继续运行； （2）当使用detach()函数时，主调线程继续运行，被调线程驻留后台运行，主调线程无法再取得该被调线程的控制权。当主调线程结束时，由运行时库负责清理与被调线程相...
C++11多线程第三篇：线程传参详解，detach()大坑，成员函数做线程参数
森明帮大于黑虎帮的博客
11-13 3568
C++11多线程第三篇：线程传参详解，detach()大坑，成员函数做线程参数
多线程中的detach
weixin_30268921的博客
08-18 385
从 thread 对象分离执行的线程，允许执行独立地持续。一旦线程退出，则释放所有分配的资源。(就是两个线程彼此相互独立) 调用detach后，*this不再占有任何线程。 #include <iostream> #include <chrono> #include <thread> void independentThrea...
C++11 thread::detach()
xikangsoon的博客
02-26 1万+
detach调用之后，目标线程就成为了守护线程，驻留后台运行，与之关联的std::thread对象失去对目标线程的关联，无法再通过std::thread对象取得该线程的控制权。当线程主函数执行完之后，线程就结束了，运行时库负责清理与该线程相关的资源。 当一个thread对象到达生命期终点而关联线程还没有结束时，则thread对象取消与线程之间的关联，目标线程线程则变为分离线程继续运行。 当调用jo...
Linux多线程环境下 关于进程线程终止函数总结
09-15
在Linux多线程环境中，理解和掌握进程线程终止的相关函数是至关重要的。这些函数用于控制线程的行为，确保程序的正常运行和资源的正确释放。以下是关于Linux多线程环境下进程线程终止函数的详细总结： 1. **pthread...
简单了解C语言中主线程退出对子线程的影响
12-23
在C语言中，线程是进程内的轻量级执行单元，主线程与子线程的关系并不像父进程和子进程那样。理解主线程退出对子线程的影响是编写多线程程序的关键。以下是对这个主题的详细阐述： 首先，我们要明确一点：线程的...
LINUX线程函数大全.pdf
12-15
pthread_detach 函数用于将非分离线程设置为分离线程。 六、线程数据 线程数据是指线程私有的数据。pthread_key_create 函数用于创建线程数据键，pthread_setspecific 函数用于设置线程数据，pthread_getspecific ...
linux_线程分离pthread_detach函数-线程取消pthread_cancel函数-线程相等pthread_equal函数
qq_44177918的博客
04-30 1390
pthread_detach函数 ②不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL错误。也就是说，如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。也就是说，如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthre
Linux中pthread_detach()线程注意
linchuanzhi_886的专栏
05-23 1万+
一、创建分离线程有两种方式创建分离线程：（1）在线程创建时将其属性设为分离状态(detached)；（2）在线程创建后将其属性设为分离的(detached)。二、分离线程的作用由系统来回收线程所占用资源。三、实例#include &lt;stdlib.h&gt;#include &lt;string.h&gt;#include &lt;unistd.h&gt;#include &lt;semaph...
47 C++ 多线程 ------ thread.detach() 的坑点
hunandede的博客
01-13 847
detach()函数的作用： 主线程不和子线程汇合了； 子线程原本关联的主线程，现在就不在和主线程关联了，这个子线程就会驻留在后台运行； 该子线程会被C++运行时库接管，当子线程执行完毕后，由运行时库（实际上是守护线程，这个要知道linux的一些相关进程线程的知识才懂，如果不懂，就大致理解为有人接管就可以了）清理该线程相关资源 detach()函数的作用的坑点 从上面的detach的作用，我们就能看到问题点。由于主线程 和 子线程分离了，那么传递参数的时候就要特别注意了。 如果从主线程传递的
详解.detach()、 .data和.detach_()
云隐雾匿的博客
07-28 1925
当我们在训练网络的时候可能希望保持一部分的网络参数不变，只对其中一部分的参数进行调整；或者只训练部分分支网络，并不让其梯度对主网络的梯度造成影响，这时候我们就需要使用detach()函数来切断一些分支的反向传播。
02C++11多线程编程之detach传参详解
weixin_44517656的博客
12-27 1096
02C++11多线程编程之detach传参详解 这篇文章将介绍我们在使用detach时如何传参给子线程。 1 detach传参为引用 #include<iostream> #include<thread> #include<string> using namespace std; void myprint1(const int &i){ //打印i的地址看是否是引用 cout << &i << endl; cout
C++-线程的join和detach
mrbone11的博客
11-07 4807
文章目录线程管理基础启动线程C++'s most vexing parsejoin或detach在发生异常的情况下joindetach 线程管理基础 启动线程 每个程序至少有一个线程：执行main()函数的线程，其余线程有其各自的入口函数。线程与原始线程(以main()为入口函数的线程)同时运行。 使用C++线程库启动线程，可以归结为构造 std::thread 对象，其构造函数传入的参数是可调用对象。 void do_some_work(); std::thread my_thread(do_some_w
小欧吃苹果-OPPO 2024届校招正式批笔试题-数据开发（C卷）
最新发布
sigd的博客
07-16 499
小欧吃苹果，拓扑排序处理贪心问题。
类中创建线程使用成员函数
06-26
在类中创建线程通常涉及使用C++标准库中的`std::thread`，以及通过成员函数来封装线程操作。以下是一个简单的步骤： 1. **定义成员函数**：首先，你需要在类中定义一个或多个成员函数，这些函数将作为线程执行的主体。这个函数通常有一个void类型，因为`std::thread`创建的线程会直接调用该函数。 ```cpp class MyClass { public: void threadFunction() { /* 你的线程任务代码 */ } }; ``` 2. **声明和定义成员函数为可调用的**：为了使`std::thread`能调用你的成员函数，你需要将其声明为`virtual`（如果需要多态行为），并提供一个非静态的、无参数的重载版本，以便作为线程目标。 ```cpp class MyClass { public: virtual void startThread() { std::thread worker(&MyClass::threadFunction, this); worker.detach(); // 可选，如果希望线程独立运行 } private: void threadFunction() { /* 你的线程任务代码 */ } }; ``` 3. **实例化并启动线程**：在类的实例上，你可以通过调用`startThread()`方法来启动一个新的线程，它会调用`threadFunction()`。 ```cpp MyClass myInstance; myInstance.startThread(); ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值