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

最新推荐文章于 2022-11-13 22:22:10 发布
最新推荐文章于 2022-11-13 22:22:10 发布
阅读量468 收藏 2
点赞数
分类专栏： C++多线程 文章标签： c++ 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/badmanwang/article/details/121053352
版权

文章目录

1、传递临时参数作为线程参数

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();

	cout << "I love China!" << endl;

	return 0;
}

对上方代码进行Debug，变量mvar的地址为0x012ffa34，它的引用mvary的地址也是0x012ffa34，而传到myprint函数里的i的地址却是0x015d1054，也就是说myprint函数的形参i不是一个真引用，而是复制了一个mvar，对复制的mvar做了一个引用给了形参i，实际上是一个值传递。

  • 分析认为，i并不是mvar的引用，实际是值传递，那么即便主线程中对子线程使用了detach()，那么子线程中的i值也是安全的。不过还是建议使用值传递，即形参为const int i，而不是const int& i。

1.2、要避免的陷阱（解释2）

示例代码：

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

//void myprint(const int i, char* pmybuf)
void myprint(const int i, const string& 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();

	cout << "I love China!" << endl;

	return 0;
}

当myprint函数第二个参数类型为char*时，通过Debug得到，main函数中，mybuf首地址为0x0118fb0c，myprint函数中的形参pmybuf的首地址也为0x0118fb0c，这样的话，当主线程对子线程使用detach()时，主线程如果先结束，mybuf内存就会被释放，pmybuf对该内存的访问可能会出错，出现不可预想的结果。

当myprint函数第二个参数类型为const string&时，通过Debug得到，main函数中，mybuf首地址为0x00fef79c，而myprint函数中形参pmybuf的首地址为0x0196f824，也就是说变量mvar传入myprint函数进行了隐式转换，而myprint函数中的pmybuf是对char[]类型的变量隐式转换成string类型而产生的临时变量的引用，那么问题来了，是什么时候进行的隐式转换呢？主线程中？还是子线程中？

**答：**事实上，主线程执行完了，mybuf都被回收了，系统才用mybuf去隐式转换为string。

  • 我们对代码进行改进并进行求证，如下：

    #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)构造函数执行]" << endl;
	}

	A(const A& a) :m_i(a.m_i)
	{
		cout << "[A::A(const A& a)拷贝构造函数执行]" << endl;
	}

	~A()
	{
		cout << "[A::~A()析构函数执行]" << endl;
	}
};

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

int main()
{
	int mvar = 1;
	int mysecondpar = 12;
	thread mytobj(myprint, mvar, mysecondpar);	//将mysecondpar转成A类型对象传递给myprint的第二个参数
	
	//mytobj.join();
	mytobj.detach();

	cout << "I love China!" << endl;

	return 0;
}

  • 当我们使用join()的时候，可以看到如下结果：

    image-20211030132459133

    说明myprint这个函数的的pmybuf确实能通过mysecondpar进行类型转换构造出一个A类对象并获得该对象的引用。

  • 但当我们使用detach()时，却看到了如下结果：

    image-20211030132944212

    说明通过mysecondpar构造的A类对象在主线程结束之前根本就没有构造出来。这样的话，主线程结束后，mysecondpar的内存空间就已经被回收了，那么再用无效的变量去构造一个A类对象，肯定会有问题，会导致一些未定义的行为。

  • 我们再次改进我们的代码，如下：

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

	A(const A& a) :m_i(a.m_i)
	{
		cout << "[A::A(const A& a)拷贝构造函数执行]" << this << endl;
	}

	~A()
	{
		cout << "[A::~A()析构函数执行]" << this << endl;
	}
};

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

int main()
{
	int mvar = 1;
	int mysecondpar = 12;
	thread mytobj(myprint, mvar, A(mysecondpar));	//将mysecondpar转成A类型对象传递给myprint的第二个参数
	
	//mytobj.join();
	mytobj.detach();

	cout << "I love China!" << endl;

	return 0;
}

  • 可以看到我们在37行对mysecondpar进行了一个强制类型转换，构造了一个临时的A类对象，可以看到如下结果：

    image-20211030140203936

    这样的话，只要用临时构造的A类对象作为参数传递给子线程，那么就一定能够在主线程执行完毕前把子线程函数的第二个参数构建出来，即便使用了detach()，子线程也能安全运行。

    证明请往下看第2部分。

1.3、总结

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

2、临时对象作为线程参数的测试方法

2.1 线程id

  • 线程id概念：id是一个数字，每个线程（不管是主线程，还是子线程）实际上都对应着一个id，每个线程对应的id不同。

  • 线程id可以用c++标准库里的函数来获取 -> std::this_thread::get_id()

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& 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;
	return;
}

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

	int mvar = 1;
	std::thread mytobj(myprint, mvar);
	//std::thread mytobj(myprint, A(mvar);
	
	mytobj.join();
	//mytobj.detach();

	cout << "I love China!" << endl;

	return 0;
}

  • 当使用join()时，所得到的结果如下：

    image-20211030143950071

    说明myprint函数的参数pmybuf的A类对象是在子线程中进行构造的，也就是说mvar隐式转换成A类对象是在子线程中进行构造的，那当使用detach()时，主线程如果先结束，mvar的内存空间就会被回收，子线程在一个无效的变量基础上进行类型的隐式转换，将会出现不可预料的错误！

  • 当我们将第38行代码进行注释，第39行代码取消注释，即在创建线程时就创建临时对象，得到结果如下：

    image-20211030144616395

    结果说明，当用了临时对象后，所有的A类对象都在main()函数中就已经构建完毕了。当我们将join()改为detach()后，得到的结果如下：

    image-20211030144914050

    结果说明，即使使用了detach()，主线程执行完毕，也不影响子线程的正常执行，因为子线程所需要的A类对象在主线程结束之前就已经构造了出来。

    注：构造函数是主线程中临时对象的构造函数，拷贝构造函数则是传递给子线程的类对象，这个拷贝构造函数是thread内部自动帮我们进行的，并传递到子线程；第一个析构函数是主线程中临时对象的析构，第二个析构则是子线程中函数传参对象的析构。

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

3.1 传递类对象

示例代码：

#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& 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)	//传入的为临时变量具有不可修改性质，必须加const
{
	pmybuf.m_i = 199;	//我们修改该值，不会影响到main()函数
	cout << "子线程myprint的参数地址为：" << & pmybuf << " threadid = " << std::this_thread::get_id() << endl;
	return;
}

int main()
{
	A myobj(10);	//生成一个类对象
	std::thread mytobj(myprint, myobj);		//将类对象作为线程参数
	
	mytobj.join();
	//mytobj.detach();

	//cout << "I love China!" << endl;

	return 0;
}

  • 当我们使用join()时，运行结果如下：

    image-20211030152550332

我们对上方代码进行Debug发现，传入到子线程中的pmybuf的地址为0x01162540，而主线程中的myobj的地址是0x00bffe84，子线程中myprint函数的形参引用并没有起作用，实际上还是利用了拷贝构造构造了一个A类对象进行传参，因此对myobj也并没有影响。那么问题来了，怎样将真正的myobj传参到子线程中减免浪费呢？接下来就轮到std:ref()出场了。

3.2 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& 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;
	return;
}

int main()
{
	A myobj(10);	//生成一个类对象
	std::thread mytobj(myprint, std::ref(myobj));		//将类对象作为线程参数
	
	mytobj.join();
	//mytobj.detach();

	//cout << "I love China!" << endl;

	return 0;
}

  • 当我们使用join()时，代码结果如下：

    image-20211030154118881

    可以看到，已经没有再调用拷贝构造函数，通过Debug可以看到myobj最初值为10，地址为0x006ffb34，传递到子线程函数中pmybuf的值为10，地址为0x006ffb34，经过子线程函数的作用，子线程函数中pmybuf的值变为199，地址为0x006ffb34,myobj的值也变为199，地址为0x006ffb34。

    说明这次是真正的将myobj传参到子线程中。

3.3 传递智能指针

示例代码：

#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& a)拷贝构造函数执行]" << this << " threadid = " << std::this_thread::get_id() << endl;
	}

	~A()
	{
		cout << "[A::~A()析构函数执行]" << this << " threadid = " << std::this_thread::get_id() << endl;
	}
};

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

int main()
{
	unique_ptr<int> myp(new int(100));
	std::thread mytobj(myprint, std::move(myp));	//独占式智能指针必须通过std::move进行传参（转移）
	
	mytobj.join();
	//mytobj.detach();

	//cout << "I love China!" << endl;

	return 0;
}
  • 在使用join()的情况下，对上方代码进行Debug，可以看到，最初的myp所指向的地址为0x01290a30，指向的值为100，传递到子线程中的智能指针pzn指向的地址也为0x01290a30，指向的值为100，传递到子线程后，myp就变为了empty。
  • 如果使用detach()，那么如果主线程执行完毕，myp被回收，而子线程还未结束或开始，子线程函数中的pzn指向的是被系统回收的一块内存，那么就将出现不可预料的问题。
  • 所以在传递智能指针时，只能使用join()，不能使用detach()。

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& 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()
{
	A myobj(10);
	std::thread mytobj(&A::thread_work, myobj, 15);
    //std::thread mytobj(&A::thread_work, std::ref(myobj), 15);
    //std::thread mytobj(&A::thread_work, &myobj, 15);
	
	mytobj.join();	
	//mytobj.detach();

	//cout << "I love China!" << endl;

	return 0;
}

使用join()代码执行结果如下：

image-20211030162246585

结果表明：thread是利用拷贝构造函数拷贝构造了一个myobj传递给了子线程，因此可以使用detach()，因为是在主线程结束之前就把拷贝构造出来的A类对象传递到了子线程。在主线程中进行拷贝构造A类对象，在子线程中对拷贝构造出来的A类对象进行析构。

如果将35行代码换成36行或者37行代码，及对myobj进行引用，这样的话就不能使用detach()，因为如果主线程先结束，myobj内存空间被回收，子线程则会对被回收的变量进行引用，即指向内存泄露的地方，会出现不可预料的后果。

3.5 对传递类对象进行改造

示例代码：

#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& 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()
{
	A myobj(10);
	std::thread mytobj(myobj, 15);
    //std::thread mytobj(std::ref(myobj), 15);	//不能使用&myobj，因为&myobj是取址，取得是this指针地址，而std::ref(myobj)是对myobj的引用
	
	mytobj.join();
	//mytobj.detach();

	//cout << "I love China!" << endl;

	return 0;
}

结果如下：

image-20211030163952651

结果表明，当不使用引用时还是内不通过拷贝构造函数传参，因此可以使用detach()。

当使用引用时，即第40行代码改为第11行代码，结果如下：

image-20211030164148306

结果表明，此时就会减少一次构造拷贝函数，提升运行速度，但同时也不能使用detach()，否则会同前面讲的一样因为内存泄漏出现不可预料的结果。

3.6 总结

  1. 在使用detach()时，不要使用引用，否则会造成内存泄漏。
  2. 在使用join()时，传递类对象最好使用引用，这样会减少拷贝构造次数，提升运行速度。
  3. 在使用引用时最好使用std::ref()，而不是&。

注：本人学习c++多线程视频地址：C++多线程学习地址

Jack丶Wang
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入分析父子线程、进程终止顺序不同产生的结果
01-20
Linux下编程，线程、进程退出顺序问题纷纷扰扰，如果父进程/线程先于子进程/线程终止，系统会做什么处理呢？反之，如果子进程/线程先于父进程/线程终止，系统又会做什么处理呢？下面是我个人平时在笔记上做的一些象征性的总结，如果有疑问之处，大可提出，我一直认为怀疑是人类进步的根本所在。一、线程Linux线程创建函数为pthread_create(),默认规则是谁创建子线程，谁就要负责子线程的资源回收，当父线程退出后，子线程也随着退出。所以，一般情况下，父线程退出时都要确保子线程已经退出，所以会使用pthread_join()函数阻塞等待子线程的退出信号/标识。pthread_detach(thre
c++11中关于std::thread的join的详解
12-31
std::thread是c++11新引入的线程标准库，通过其可以方便的编写与平台无关的多线程程序，虽然对比针对平台来定制化多线程库会使性能达到最大，但是会丧失了可移植性，这样对比其他的高级语言，可谓是一个不足。终于在c++11承认多线程的标准，可谓可喜可贺！！！ 在使用std::thread的时候，对创建的线程有两种操作：等待/分离，也就是join/detach操作。join()操作是在std::thread t(func)后“某个”合适的地方调用，其作用是回收对应创建的线程的资源，避免造成资源的泄露。detach()操作是在std::thread t(func)后马上调用，用于把被创建的线程
简单了解C语言中主线程退出对子线程的影响
12-23
这篇文章主要介绍了简单了解C语言中主线程退出对子线程的影响,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 对于程序来说，如果主进程在子进程还未结束时就已经退出，那么Linux内核会将子进程的父进程ID改为1（也就是init进程），当子进程结束后会由init进程来回收该子进程。 那如果是把进程换成线程的话，会怎么样呢？假设主线程在子线程结束前就已经退出，子线程会发生什么？ 在一些论坛上看到许多人说子线程也会跟着退出，其实这是错误的，原因在于他们混淆了线程退出和进程退出概念。实际的答案是主线程退出后子线程的状态依赖于它所在的进程，如果进程没有退出
多线程API.zip
04-30
常见的多线程API和用法 pthread_self函数 pthread_create函数 pthread_exit函数 pthread_join函数 pthread_detach函数 pthread_equal函数
c++11多线程编程
04-09
c++11多线程库的使用，主要介绍了thread类中的构造函数 join函数和detach函数的使用方式
C++11多线程第三篇：线程传参详解，detach()大坑，成员函数做线程参数
森明帮大于黑虎帮的博客
11-13 3431
C++11多线程第三篇：线程传参详解，detach()大坑，成员函数做线程参数
C++ 多线程detach()操作的坑以及传参
jinking01的专栏
09-16 1万+
detach()的作用是将子线程和主线程的关联分离，也就是说detach()后子线程在后台独立继续运行，主线程无法再取得子线程的控制权，即使主线程结束，子线程未执行也不会结束。当主线程结束时，由运行时库负责清理与子线程相关的资源。实际应用如让一个文字处理应用同时编辑多个文档，让每个文档处理窗口拥有自己的线程，每个线程运行同样的代码，并隔离不同窗口处理的数据。 1 #include <thread> 2 #include <iostream> 3 4 using name
02C++11多线程编程之detach传参详解
weixin_44517656的博客
12-27 1076
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++11多线程注意事项以及detach中的坑
热门推荐
那又怎样的博客
05-02 1万+
多线程编程是必须要掌握的，以前多线程基本是靠系统API或者第三方库完成的，比如windows的API函数CreateThread，linux创建线程函数pthread_create，但是这样编写的代码不可移植，不能跨平台，比如windows的多线程程序拿到linux下是跑不起来的，相反也一样，很不方便，然而C++11语言本身支持多线程，和平台无关，下面就来简单认识多线程 # include<...
C/C++ 内存泄漏-原因、避免以及定位
C语言与CPP编程的博客
05-07 2305
大家好！作为C/C++开发人员，内存泄漏是最容易遇到的问题之一，这是由C/C++语言的特性引起的。C/C++语言与其他语言不同，需要开发者去申请和释放内存，即需要开发者去管理内存，如果内存使用不当，就容易造成段错误(segment fault)或者内存泄漏(memory leak)。今天，借助此文，分析下项目中经常遇到的导致内存泄漏的原因，以及如何避免和定位内存泄漏。主要...
C++11多线程 多线程传参详解
u012507022的博客
01-05 4775
1.传递临时对象做线程参数 1.1要避免的陷阱1 用detach()时，如果主线程先结束，变量就会被回收；所以用detach()的话，不推荐用引用，同时绝对不能用指针。 1.2要避免的陷阱2 只要临时对象的用临时构造A类对象作为参数传递给线程，那么就一定能够在主线程结束之前，把线程函数的第二个参数构建出来，从而确保即便detach()子线程也安全运行，程序如下： #include&lt...
（C++11/14/17学习笔记）：线程传参详解，detach()陷阱，成员函数做线程函数
baidu_41388533的博客
12-08 608
线程传参详解，detach()陷阱，成员函数做线程函数 传递临时对象作为线程参数 【引例】 #include <iostream> #include <string> #include <thread> using namespace std; void myprint(const int& i, char* pmybuf ) { cout << i << endl; cout << pmybu...
thread 泄露问题
小青年儿
08-09 1010
解决了一个隐蔽的内存泄漏——pthread_create后没有pthread_join导致内存持续增长 昨天解决了一个隐蔽的内存泄漏问题，原因是pthread_create后的僵死线程没有释放导致的内存持续增长。 现象是这样的：短时间内程序运行正常，但跑了12小时左右，用top查看其内存占用居然高达2G，于是马上意识到有内存泄漏。 最先想到的是malloc/free、new/
小题大做 | Handler内存泄露全面分析
积木点点滴滴
12-24 443
前言 嗨，大家好，问大家一个“简单”的问题： Handler内存泄露的原因是什么？ 你会怎么答呢？ 这是错误的回答 有的朋友看到这个题表示，就这？太简单了吧。 “内部类持有了外部类的引用，也就是Hanlder持有了Activity的引用，从而导致无法被回收呗。” 其实这样回答是错误的，或者说没回答到点子上。 内存泄漏 Java虚拟机中使用可达性分析的算法来决定对象是否可以被回收。即通过GCRoot对象为起始点，向下搜索走过的路径（引用链），如果发现某个对象或者对象组为不可达状态，则将其进行回收。 而内存泄漏
C++11 Bug分析：std::thread用法不当引发的灾难
DU_YULIN的博客
08-23 1590
std::thread用法不当引发的灾难：camera应用程序闪退
c++11用类的成员函数创建线程
qq_23069315的博客
05-10 6425
c++11用类的成员函数创建线程当需要利用类成员函数( MyClass::thread_func )来创建子线程时，需如下码码：t[i] = thread(std::mem_fn(&amp;MyClass::thread_func), Object, args..); 如果thread_func为static，则不用写object。否则需要，如主进程所调函数也为该类成员，则传入this指回自...
C++11/std::thread - 可作为线程函数的几种方式总结
HW140701的博客
04-01 3138
1 使用普通的函数作为线程函数 代码示例： #include <iostream> #include <thread> void ThreadFunction() { std::cout<< "线程函数被启动" << std::endl; } int main() { std::thread thread(ThreadFunct...
关于C++使用thread的detach函数之后
qq_44879626的博客
03-06 1004
定义一个子线程初始函数，当创建一个子线程时，如果传入的是类对象的引用，那么会重新创立一个类对象，但是如果使用detach的话，如何保证安全。就是如何保证主线程运行完前完成创建副本对象。将对象先转换一下就可以。 std::thread myobj(myprintf2, Node(myp);//去除Node后不能保证安全 智能指针的写法： unique_ptr<int> p; #include<iostream> using namespace std; void mypri
C++11并发与多线程（3）线程传参详解、detach()大坑、成员函数做线程函数
qq_33435360的博客
05-24 302
（1）传递临时对象作为线程参数 （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 <
c++多线程将指针函数传给C#委托
最新发布
08-12
下面是一个示例代码，演示了如何在C++多线程中将指针函数传递给C#委托： 首先，定义一个C++的指针函数，用于在多线程中执行任务： ```cpp // C++头文件 typedef void(__stdcall *CallbackFunction)(int); extern...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值