0
点赞
收藏
分享

微信扫一扫

《c++新经典》C++11并发与多线程笔记(3)

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

在这里插入图片描述

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

1.2要避免的陷阱2:

#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.3 总结

  • 如果传递int这种简单类型,推荐使用值传递,不要用引用
  • 如果传递类对象,避免使用隐式类型转换,全部都是创建线程这一行就创建出临时对象,然后在函数参数里,用引用来接,否则还会创建出一个对象
  • 终极结论:建议不使用detach

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

2.1线程id概念

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

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

3.1传递类对象

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

3.2传递智能指针

#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));
	myThread.join();
	//myThread.detach();

	return 0;
}

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

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <thread>
using namespace std;

class A
{
public:
	mutable int m_i;
	A(int a) :m_i(a)
	{
		std::cout << "[A::A(int a)构造函数执行]" << this << " thread_id = " <<
			std::this_thread::get_id() << std::endl;
	}
	A(const A &a) :m_i(a.m_i)
	{
		std::cout << "[A::A(const A)拷贝构造函数执行]" << this << " thread_id = " <<
			std::this_thread::get_id() << std::endl;
	}
	~A()
	{
		std::cout << "[A::~A()析构函数执行]" << this << " thread_id = " <<
			std::this_thread::get_id() << std::endl;
	}

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

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


int main(int argc, char* argv[])
{
	//A myobj(10);//生成一个类对象
	//std::thread mytobj(&A::ThreadWork, myobj, 15);
	//mytobj.join();

	A myobj(10);//生成一个类对象
	std::thread mytobj(myobj, 15);
	mytobj.join();
	
	system("pause");
	return 0;
}
举报

相关推荐

0 条评论