编程语言
首页 > 编程语言> > 2021/10/1C++11并发与多线程笔记(2) 线程启动、结束,创建线程多法、join,detach

2021/10/1C++11并发与多线程笔记(2) 线程启动、结束,创建线程多法、join,detach

作者:互联网

一、范例演示线程运行的开始

创建一个线程:

  1. 包含头文件thread
  2. 写初始函数
  3. 在main中创建thread

必须要明白:有两个线程在跑,相当于整个程序中有两条线在同时走,即使一条被阻塞,另一条也能运行
在这里插入图片描述
1.1 thread
(1) 创建了线程,线程执行起点(入口)是myPrint;
(2) 执行线程
1.2 join()
阻塞主线程并等待myPrint执行完,当myPrint执行完毕,join()就执行完毕,主线程继续往下执行; join意为汇合,子线程和主线程回合
1.3 detach()
传统多线程程序,主线程要等待子线程执行完毕,然后自己最后退出。
detach: 分离,主线程不再与子线程汇合,不再等待子线程
detach后,子线程和主线程失去关联,驻留在后台,由C++运行时库接管
一旦detach到后台,就不能再join回了,否则系统会调用异常
1.4 joinable()
判断是否可以成功使用join()或者detach()
如果返回true,证明可以调用join()或者detach()
如果返回false,证明调用过join()或者detach(),join()和detach()都不能再调用了

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

void myPrint()
{
	cout << "我的线程开始运行" << endl;
	//-------------
	//-------------
	cout << "我的线程运行完毕" << endl;
	return;
}

int main()
{
	//(1)创建了线程,线程执行起点(入口)是myPrint;(2)执行线程
	thread myThread(myPrint);

	//(2)阻塞主线程并等待myPrint执行完,当myPrint执行完毕,join()就执行完毕,主线程继续往下执行
	//join意为汇合,子线程和主线程回合
	myThread.join();

	//设置断点可看到主线程等待子线程的过程
	//F11逐语句,就是每次执行一行语句,如果碰到函数调用,它就会进入到函数里面
	//F10逐过程,碰到函数时,不进入函数,把函数调用当成一条语句执行

	//(3)传统多线程程序中,主线程要等待子线程执行完毕,然后自己才能向下执行
	//detach:分离,主线程不再与子线程汇合,不再等待子线程
	//detach后,子线程和主线程失去关联,驻留在后台,由C++运行时库接管
	//myThread.detach();

	//(4)joinable()判断是否可以成功使用join()或者detach()
	//如果返回true,证明可以调用join()或者detach()
	//如果返回false,证明调用过join()或者detach(),join()和detach()都不能再调用了
	if (myThread.joinable())
	{
		cout << "可以调用可以调用join()或者detach()" << endl;
	}
	else
	{
		cout << "不能调用可以调用join()或者detach()" << endl;
	}
	
	cout << "Hello World!" << endl;
	return 0;
}

重要补充:
线程类参数是一个可调用对象。
一组可执行的语句称为可调用对象,c++中的可调用对象可以是函数函数指针lambda表达式bind创建的对象或者重载了函数调用运算符的类对象

二、其他创建线程的方法
(1) 创建一个类,并编写圆括号重载函数,初始化一个该类的对象,把该对象作为线程入口地址

class Ta
{
public:
	void operator()() //不能带参数
	{
		cout << "我的线程开始运行" << endl;
		//-------------
		//-------------
		cout << "我的线程运行完毕" << endl;
	}
};

//main函数里的:
	Ta ta;
	thread myThread(ta);
	myThread.join();

一个疑问,一旦调用了detach(),那主线程执行结束了,我这里用的这个ta这个对象还在吗? 这个对象实际上是被复制到线程中去的。执行完主线程后,ta会被销毁,但所复制的Ta对象依然存在。
所以,只要TA类对象里没有引用,没有指针,那么就不会产生问题;

(2) lambda表达式创建线程

//main函数中
auto lambdaThread = [] {
		cout << "我的线程开始执行了" << endl;
		//-------------
		//-------------
		cout << "我的线程开始执行了" << endl;
	};

	thread myThread(lambdaThread);
	myThread.join();

(3) 把某个类中的某个函数作为线程的入口地址

class Data_
{
public:
    void GetMsg(){}
    void SaveMsh(){}
};
//main函数里
    Data_ s;
    //第一个&意思是取址,第二个&意思是引用,相当于std::ref(s)
    //thread oneobj(&Data_::SaveMsh,s)传值也是可以的
    //在其他的构造函数中&obj是不会代表引用的,会被当成取地址
    //调用方式:对象成员函数地址,类实例,[成员函数参数]
	//第二个参数可以传递对象s,也可以传递引用std::ref(s)或&s
	//传递s,会调用拷贝构造函数在子线程中生成一个新的对象
	//传递&,子线程中还是用的原来的对象,所以就不能detach,因为主线程运行完毕会把该对象释放掉
    thread oneobj(&Data_::SaveMsh,&s);
    thread twoobj(&Data_::GetMsg,&s);
    oneobj.join();
    twoobj.join();

标签:11,执行,多线程,join,主线,调用,线程,detach
来源: https://blog.csdn.net/caiprivate/article/details/120577458