📕线程启动、结束、创建方法

一、线程启动的开始

程序运行起来：生成一个进程，该进程所属的主线程开始自动运行；当主线程从main（）函数返回，则整个进程执行完毕 主线程从main（）开始执行；那么我们自己创建的线程，也需要从一个函数开始运行（初始函数），一旦这个函数运行完毕，线程也结束运行； 整个进程是否执行完毕的标志是：主线程是否执行完，如果主线程执行完毕了，就代表整个进程执行完毕了，此时如果其他子线程还没有执行完，也会被强行终止。但是！！！！c++也可以让子线程独立出来，不受到主线程是否结束所影响（下面会说明；但是我们都用受主线程影响的，更可靠）；

创建一个线程：①包含头文件thread ②写初始函数 ③在main中创建thread ④选择线程的主线程的相关函数（join还是detach，不进行选择会发生错误，线程没运行完就强迫退出）； 必须要明白：有两个线程在跑，相当于整个程序中有两条线在同时走，即使一条被阻塞，另一条也能运行

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

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

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

//(3)join意为汇合，等待线程完成函数(一般用这个)
//作用①阻塞主线程并等待myPrint执行完，当myPrint执行完毕，join()就执行完毕，主线程继续往下执行；②清理子线程相关的存储器，thread不再与子线程相关联，释放子线程中的资源
myThread.join();

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

//(5)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创建的对象或者重载了函数调用运算符(“()”)的类对象。

二、其他创建线程的方法

①创建一个类，并编写函数调用运算符重载函数，初始化一个该类的对象，把该对象作为线程入口地址

#include <iostream>
#include<thread>

using namespace std;

class TA
{
public:
int m_i;
//错误做法
//TA(int &i):m_i(i) {} //这里采用引用的话用detach分离，就会错误，因为这个对象在另一个线程中，有用到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 << "m_i1的值为： " << m_i << endl; //问题一：如果采用detach分离的，m_i是引用,主线程结束后释放m_i,因为这个线程没有结束，找不到m_i了，这里会产生不可预估的结果
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);//main主线程中的对象 + 仿函数中的参数
thread mytobj3(ta);//ta:可调用对象，问题二：这个对象主线程结束了，这里ta会不会释放，会不会产生错误？对象不在了，但是对象实际上是被复制到线程中，主线程结束释放ta后，但是复制的TA对象仍然存在；可看跑的结果； 如果采用join的话。这里还会有个临时对象析构的过程；
mytobj3.detach();

cout << "我是主线程h" << endl;
cout << "我是主线程hh" << endl;
cout << "我是主线程hhh" << endl;
return 0;
}

②lambda表达式创建线程

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

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

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

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