第二节 线程启动、结束、创建线程多法，join，detach

1. 范例演示线程运行的开始和结束

          整个进程是否执行完毕的标志是主线程是否执行完，如果主线程执行完毕了，就代表整个进程执行完毕了。所以一般情况下（不使用detach的情况下），要保持子线程的运行状态就需要保持主程序的运行状态。有两个线程在跑，相当于整个程序的执行有两条线同时在走，所以，可以同时干两件事，即使有一条线堵住了也不会影响另外一条线的运行。 

1.1 thread

thread 是个标准库里的类，写多线程程序时需要在头文件里添加#include<thread>。

#include<thread>
void myprint()
{
    cout<<"我的线程开始执行了"<<endl;
    cout<<"我的线程执行完了"<<end;
}
int main()
{
    thread mytobj(myprint);//创建了线程，线程执行起点（入口）myprint()是可调用对象
    mytobj.join();//注释掉后线程运行会出现异常
    cout<<"I love China"
    return 0;
}

 

1.2 join（）

        join起阻塞的作用，阻塞主线程，让主线程等待子线程执行完毕，然后子线程和主线程汇合，然后主线程再往下走。运行结果如下。

如果注释掉join代码行，程序就会出现异常，比如主程序执行完了，但是子程序没有执行完。结果如下：

 

1.3 detach（）

       也就是主线程不和子线程汇合了，主线程和子线程各自执行自己的。为什么要引入detach（）呢，因为我们创建了很多子线程，让主线程逐个等待子线程结束，这种编程方法不太好，所以引入了detach（）。一旦detach（）之后，与这个主线程相关联的thread对象就会失去与这个主线程的关联，此时这个子线程就会驻留在后台运行，这个子线程就相当于被C++运行时库接管，当这个子线程执行完成后，由运行时库负责清理该线程相关的资源。 

 

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


void myprint()
{
	cout << "我的线程开始执行了"<<endl;
	cout << "我的线程执行完了"<<endl;
}
int main()
{
	thread mytobj(myprint);//创建了线程，线程执行起点（入口）myprint()是可调用对象
	//mytobj.join();
	mytobj.detach();
	cout << "主程序收尾，安全退出1"<<endl;
	cout << "主程序收尾，安全退出2"<< endl;
	cout << "主程序收尾，安全退出3"<< endl;
	cout << "主程序收尾，安全退出4"<< endl;
	cout << "主程序收尾，安全退出5"<< endl;
	cout << "主程序收尾，安全退出6"<< endl;
	cout << "主程序收尾，安全退出7"<< endl;
	cout << "主程序收尾，安全退出8"<< endl;
	cout << "主程序收尾，安全退出9"<< endl;
	return 0;
}

 

可以看到，输出的结果出现了混乱。还要注意的是，一旦调用了detach（）就不能再调用join（），否则系统会报告异常。

 

1.4 joinable（）

    判断是否可以成功调用join（）或者detach（）；返回true（可以join或者detach）或者false（不能join或者detach）。

thread mytobj(myprint);
if(mytob.joinable())
{
    mytobj.join();
}

2.其他创建线程的手法

2.1用类，以及一个问题范例

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


void myprint()
{
	cout << "我的线程开始执行了"<<endl;
	cout << "我的线程执行完了"<<endl;
}
/*
int main()
{
	thread mytobj(myprint);//创建了线程，线程执行起点（入口）myprint()是可调用对象
	//mytobj.join();
	mytobj.detach();
	cout << "主程序收尾，安全退出1"<<endl;
	cout << "主程序收尾，安全退出2"<< endl;
	cout << "主程序收尾，安全退出3"<< endl;
	cout << "主程序收尾，安全退出4"<< endl;
	cout << "主程序收尾，安全退出5"<< endl;
	cout << "主程序收尾，安全退出6"<< endl;
	cout << "主程序收尾，安全退出7"<< endl;
	cout << "主程序收尾，安全退出8"<< endl;
	cout << "主程序收尾，安全退出9"<< endl;
	return 0;
}
*/
class TA
{
public:
	void operator()()
	{
		cout << "我的线程operator()开始执行了" << endl;
		cout << "我的线程operator()结束执行了" << endl;
	}
};

int main()
{
	TA ta;
	thread mytobj3(ta);//ta可调用对象
	mytobj3.join();//等待子线程执行结束
	cout << "I love China" << endl;
	return 0;
}

注意一种情况

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


void myprint()
{
	cout << "我的线程开始执行了"<<endl;
	cout << "我的线程执行完了"<<endl;
}
/*
int main()
{
	thread mytobj(myprint);//创建了线程，线程执行起点（入口）myprint()是可调用对象
	//mytobj.join();
	mytobj.detach();
	cout << "主程序收尾，安全退出1"<<endl;
	cout << "主程序收尾，安全退出2"<< endl;
	cout << "主程序收尾，安全退出3"<< endl;
	cout << "主程序收尾，安全退出4"<< endl;
	cout << "主程序收尾，安全退出5"<< endl;
	cout << "主程序收尾，安全退出6"<< endl;
	cout << "主程序收尾，安全退出7"<< endl;
	cout << "主程序收尾，安全退出8"<< endl;
	cout << "主程序收尾，安全退出9"<< endl;
	return 0;
}
*/
class TA
{
public:
	int &m_i;
	TA(int &i):m_i(i) {}
	void operator()()
	{
		//cout << "我的线程operator()开始执行了" << endl;
		//cout << "我的线程operator()结束执行了" << endl;
		cout << "m_i1的值为" << m_i << endl;
		cout << "m_i2的值为" << m_i << endl;
		cout << "m_i3的值为" << m_i << endl;
		cout << "m_i4的值为" << m_i << endl;
		cout << "m_i5的值为" << m_i << endl;
	}
};

int main()
{
	int myi = 6;
	TA ta(myi);
	thread mytobj3(ta);
	//mytobj3.join();
	mytobj3.detach();
	cout << "I love China1" << endl;
	return 0;
}

 

当主线程先执行完了之后，主线程的变量就会被销毁，比如这里引用的m_i,如果换做整型就没有问题。引用传的是地址，而数值传递的数值的拷贝，比如这里的ta是传值，是被复制到线程中去的，所以主线程执行完之后ta被销毁，但是ta的复制还是在的。

2.2 用lambda表达式

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

int main()
{
	auto mylamthread = [] {
		cout << "我的线程3开始执行了" << endl;
		//、、
		cout << "我的线程3执行结束了" << endl;

	};
	thread mytobj4(mylamthread);
	mytobj4.join();
	cout << "I love China" << endl;
	return 0;
}