2.线程启动、结束、创建线程多发、join，detach

目录：

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

1）程序运行起来，生成一个进程，该进程所属的主线程开始自动运行

2）主线程从main（）开始执行，那么我们自己创建的线程，也需要从一个函数开始运行（初始函数），一旦这个函数运行完毕，就代表着我们这个线程运行完毕

3）整个进程是否完毕的标志是 主线程是否执行完，如果主线程执行完毕了，就代表整个进程执行完毕了。此时，如果其他子线程还没有执行完毕，那么这些子线程也会被操作系统强行终止。

​ 所以，一般情况下，我们将得到一个结论，如果大家想保持线程（自己用代码创建的）运行状态的话，那么大家要让主线程一直保持运行，不要让主线程运行完毕（这条规律也有例外，后续会解释这种例外（就是1.3 detach），大家目前先这样理解和记忆）

创建一个线程：

1）包含一个头文件 #include <thread>

2）初始函数要写

3） main中开始写代码

注意：有两个线程在跑，相当于两个程序的执行有两条线在同时走，所以，可以同时运行两个事情，即使一条线被堵住了，另外一条线还是可以运行，这就是多线程。

创建线程示范如下：

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

//自己创建的线程也要从一个函数（初始函数）开始运行
void myprint() {
	cout << "我的线程开始执行了1" << endl;
    cout << "我的线程开始执行了2" << endl;
    cout << "我的线程开始执行了3" << endl;

	cout << "我的线程执行完毕了" << endl;
}


int main() {
	//a)包含一个头文件 #include <thread>

	//b)初始函数要写 例如上面的void myprint()；

	//c) main中开始写代码
	thread mytobj(myprint);  //（1）创建了线程，线程执行起点（入口）myprint（）； （2）myprint开始执行
    
    //阻塞主线程并等待myprint子线程执行完
	mytobj.join(); //主线程阻塞到这里，等待myprint()执行完，当子线程执行完毕，这个join（）就执行完毕，主线程就继续往下执行

	cout << "主线程收尾，最终主线程正常退出" << endl;

	//大家必须明确一点：有两个线程在跑，相当于两个程序的执行有两条线在同时走，所以，可以同时运行两个事情，即使一条线被堵住了，另外一条线还是可以运行，这就是多线程
	return 0;
}

运行结果：

1.1 therad

概念：thread是个标准库里的类。

thread mytobj(myprint);//（1）创建了线程，线程执行起点（入口）myprint（）； （2）myprint开始执行

1.2 join

概念：join（）：加入/汇合，说白了就是阻塞，阻塞主线程，让主线程等待子线程执行完毕然后子线程和主线程汇合，然后主线程再往下走。

注意：如果主线程执行完毕，但子程序没执行完毕，这种程序员是不合格的，程序也是不稳定的。

​ 一个书写良好的程序，应该是主线程等待子线程执行完毕后，自己才能最终退出。

//阻塞主线程并等待myprint子线程执行完
mytobj.join();  //主线程阻塞到这里，等待myprint()执行完，当子线程执行完毕，这个join（）就执行完毕，主线程就继续往下执行

1.3 detach()

1）概念：传统多线程程序主线程要等待子线程执行完毕，然后自己再最后退出。

2）detach：分离，也就是主线程不和子线程汇合了，你主线程执行你的，我子线程执行我的，你主线程也不必等我子线程运行完毕，你可以先执行结束，这并不影响我子线程的执行。

（下面为什么的解释说明：但是老师还是推荐实际项目不要这样，让子线程执行完毕再说，权当概念记）

3）为什么引入detach：我们创建了很多子线程，让主线程逐个等待子线程结束，这种编程方法不好==（书上写的，不用信）==，所以引入detach（）；一旦detach（）之后，与这个主线程关联的thread对象就会失去与这个主线程的关联，此时这个子线程就会驻留在后台运行（主线程跟子线程失去联系）；这个子线程就相当于被c++运行时库接管，当这个子线程执行完毕后，由运行时库负责清理该线程相关的资源（守护线程）。

4）注意：一旦调用了detach（）。就不能再使用join（）

例子里面 detach（）使线程myprint失去我们自己的控制

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

//自己创建的线程也要从一个函数（初始函数）开始运行
void myprint() {
	cout << "我的线程开始执行了1" << endl;
    cout << "我的线程开始执行了2" << endl;
    cout << "我的线程开始执行了3" << endl;

	cout << "我的线程执行完毕了" << endl;
}


int main() {

	thread mytobj(myprint);  //（1）创建了线程，线程执行起点（入口）myprint（）； （2）myprint开始执行
    mytobj.detach();  //一旦调用了detach（）。就不能再使用join（）

	cout << "主线程收尾，最终主线程正常退出1" << endl;
    cout << "主线程收尾，最终主线程正常退出2" << endl;
    cout << "主线程收尾，最终主线程正常退出3" << endl;
    cout << "主线程收尾，最终主线程正常退出4" << endl;


	return 0;
}

运行结果：

如果主线程的最后一步运行完了，就退出了，其他子线程就输出不来了

1.4 joinable()

概念：判断是否可以成功使用join（）或者detach（）。返回true（可以使用join（）或者detach（））或者false（不可以使用）

即，使用了join（）就不可以再detach（），使用了detach（）就不可以再join（）；

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

//自己创建的线程也要从一个函数（初始函数）开始运行
void myprint() {
	cout << "我的线程开始执行了" << endl;

	cout << "我的线程执行完毕了" << endl;
}


int main() {

	thread mytobj(myprint);  //（1）创建了线程，线程执行起点（入口）myprint（）； （2）myprint开始执行
	if(mytobj.joinable()){      //这里输出1.joinable() == true
		cout<<"1.joinable() == true"<<endl;
	}
	else{
		cout<<"1.joinable() == false"<<endl;
	}
    mytobj.detach();  //一旦调用了detach（）。就不能再使用join（）
    if(mytobj.joinable()){   //这里输出2.joinable() == false
		cout<<"2.joinable() == true"<<endl;
	}
	else{
		cout<<"2.joinable() == false"<<endl;

	cout << "主线程收尾，最终主线程正常退出" << endl;

	return 0;
}

二、其他创建线程的方法

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

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

class TA
{
public:
	void operator()() //不能带参数，重载了()
	{
		cout << "我的线程开始执行了" << endl;

		cout << "我的线程执行完毕了" << endl;
	}
};

int main() {
	//2.1 用类对象（可调用对象），以及一个问题范例
	TA ta;
	thread mytobj3(ta); //ta可调用对象
	mytobj3.join();    //等子线程执行结束


	cout << "主线程收尾，最终主线程正常退出" << endl;
	return 0;
}

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

class TA
{
public:
	int &m_i;
	TA(int &i) :m_i(i) {
        cout<<"TA()构造函数被执行"<<endl;
    };
    TA(const TA & ta) :m_i(ta.m_i) {  //因为是复制的，所以调用了拷贝构造
        cout<<"TA()拷贝构造函数被执行"<<endl;
    };
    ~TA(){
        cout<<"TA()析构函数被执行"<<endl;
    }
	void operator()() //不能带参数，重载了()
	{
		cout << "我的线程开始执行了" << endl;

		cout << "m_i的值为" <<m_i<< endl;


		cout << "我的线程执行完毕了" << endl;
	}
};

int main() {
	//2.1 用类对象（可调用对象），以及一个问题范例
	int myi = 0;
	TA ta(myi);
	thread mytobj3(ta); //ta可调用对象
	mytobj3.detach();    


	cout << "主线程收尾，最终主线程正常退出" << endl;
	return 0;
}

分析：

1）myi为局部变量，引用过去如果主线程运行完，那myi就被销毁了

2）为什么会有拷贝构造？因为这个对象实际上是被复制到线程中去的

3）为什么析构两次？例子1里那个第一次是复制的那个ta的析构，第二次是ta的析构，例子2里那个是ta的析构

可能还有一个疑问：

一旦detach（），那主线程执行结束了，我这里用的这个ta这个对象还在吗？（对象不在，这个对象实际上是被复制到线程中去，执行完线程后，ta会被销毁，但是所复制的ta对象依旧存在，所以，只要你这个TA类对象里没有引用，没有指针，那么就不会产生问题）

可以用join（）看看正常的

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

class TA
{
public:
	int &m_i;
	TA(int &i) :m_i(i) {
        cout<<"TA()构造函数被执行"<<endl;
    };
    TA(const TA & ta) :m_i(ta.m_i) {  //因为是复制的，所以调用了拷贝构造
        cout<<"TA()拷贝构造函数被执行"<<endl;
    };
    ~TA(){
        cout<<"TA()析构函数被执行"<<endl;
    }
	void operator()() //不能带参数，重载了()
	{
		cout << "我的线程开始执行了" << endl;

		cout << "m_i的值为" <<m_i<< endl;


		cout << "我的线程执行完毕了" << endl;
	}
};

int main() {
	//2.1 用类对象（可调用对象），以及一个问题范例
	int myi = 0;
	TA ta(myi);
	thread mytobj3(ta); //ta可调用对象
	mytobj3.join();    


	cout << "主线程收尾，最终主线程正常退出" << endl;
	return 0;
}

也可以不用引用，也能正常

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

class TA
{
public:
	int m_i;
	TA(int i) :m_i(i) {
        cout<<"TA()构造函数被执行"<<endl;
    };
    TA(const TA & ta) :m_i(ta.m_i) {  //因为是复制的，所以调用了拷贝构造
        cout<<"TA()拷贝构造函数被执行"<<endl;
    };
    ~TA(){
        cout<<"TA()析构函数被执行"<<endl;
    }
	void operator()() //不能带参数，重载了()
	{
		cout << "我的线程开始执行了" << endl;

		cout << "m_i的值为" <<m_i<< endl;


		cout << "我的线程执行完毕了" << endl;
	}
};

int main() {
	//2.1 用类对象（可调用对象），以及一个问题范例
	int myi = 0;
	TA ta(myi);
	thread mytobj3(ta); //ta可调用对象
	mytobj3.join();    


	cout << "主线程收尾，最终主线程正常退出" << endl;
	return 0;
}

这边m_i2是还没来得急显示

2.2 用lambda

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



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

		cout << "我的线程执行结束了" << endl;
	};

	thread mytobj4(mylamthread);
	mytobj4.join();

	cout << "主线程收尾，最终主线程正常退出" << endl;
	return 0;
}