C++11并发与多线程笔记---------- 线程启动、结束，创建线程多法、join，detach

本文的笔记是根据如下视频教学的笔记记录：c++11并发与多线程视频课程
第二节：线程启动。结束，创建线程多法，join，detach

1 范例演示线程运行的开始

1.1 主线程和子线程的关系

• 程序运行起来，生成一个进程，该进程所属的主线程开始自动运行；当主线程从main（）函数返回，则整个进程执行完毕。
• 主线程从main（）开始执行，自己创建的线程，需要从一个函数开始运行（初始函数），一旦这个函数运行完毕，线程也结束运行。
• 整个进程是否执行完毕的标志是：主线程是否执行完，如果主线程执行完毕了，就代表整个进程执行完毕了，此时如果其他子线程还没有执行完，也会被强行终止【此条有例外，以后会解释】一般为了让子线程运行，就不能结束主线程的。

1.2 创建线程的要素

• 包含头文件thread
• 写出初始函数
• 在main中创建thread

必须要明白：有两个线程在跑，相当于整个程序中有两条线在同时走，即使一条被阻塞，另一条也能运行

#include "bits/stdc++.h"
#include "thread"
using namespace std;
//自己创建的线程要从一个函数开始运行的。
void myprint(){
    cout<<"thread start"<<endl;
    cout<<"tianitn i love china 111111"<<endl;
    cout<<"tianitn i love china 2"<<endl;
    cout<<"tianitn i love china 3"<<endl;
    cout<<"tianitn i love china 111114"<<endl;
    cout<<"tianitn i love china 111115"<<endl;
    cout<<"tianitn i love china 111116"<<endl;
    cout<<"tianitn i love china 111117"<<endl;
    cout<<"tianitn i love china 111118"<<endl;
    cout<<"tianitn i love china 111119"<<endl;
    cout<<"tianitn i love china 1111123"<<endl;
    cout<<"tianitn i love china 111112432"<<endl;
    cout<<"tianitn i love china 1111ww232"<<endl;
    cout<<"thread end"<<endl;
}

int main(){
    //一，范例演示线程的开始和结束
    // 程序运行起来，生成一个进程，该进程所属的主线程自动执行

    //1 程序运行起来，生成一个进程，该进程所属的主线程开始自动运行；当主线程从main（）函数返回，则整个进程执行完毕
    //2 主线程从main（）开始执行，那么我们自己创建的线程，也需要从一个函数开始运行（初始函数），一旦这个函数运行完毕，线程也结束运行
    //3 整个进程是否执行完毕的标志是：主线程是否执行完，如果主线程执行完毕了，就代表整个进程执行完毕了，此时如果其他子线程还没有执行完，也会被强行终止【此条有例外，以后会解释】

    //创建线程的要素
    //    - 包含头文件thread
    //    -  写出初始函数
    //    -  在main中创建thread

    //必须要明白：有两个线程在跑，相当于整个程序中有两条线在同时走，即使一条被阻塞，另一条也能运行
    //(1) thread  标准库的类,  myprint 可调用对象
    //(2) join  加入/汇合  阻塞主线程，让主线程等待子线程执行完毕，然后主线程和子线程汇合，然后结束
    //书写良好的程序，主线程应该等待子线程执行结束，然后自己才能退出。
    //(3)传统多线程程序中，主线程要等待子线程执行完毕，然后自己才能向下执行
    //detach:分离，主线程不再与子线程汇合，不再等待子线程,主线程和子线程各自执行  并不相关
    //detach后，子线程和主线程失去关联，驻留在后台，由C++运行时库接管，清理该线程的相关的资源（linux是守护线程）
    //myThread.detach();
    // joinable()  判断是不是可以成功的使用join()或者detach()  返回true（可以join）


    thread mytobj(myprint);//（1）创建了线程，  线程的起点和入口  myprint  （2）myprint线程开始执行
    //mytobj.join();  //(2)阻塞主线程并等待myPrint执行完，当myPrint执行完毕，join()就执行完毕，主线程继续往下执行
    if (mytobj.joinable())
    {
        cout << "可以调用可以调用join()或者detach()" << endl;
    }
    else
    {
        cout << "不能调用可以调用join()或者detach()" << endl;
    }
    mytobj.detach();//  一旦使用detach（）  不能在使用了join的情况的
    if (mytobj.joinable())
    {
        cout << "可以调用可以调用join()或者detach()" << endl;
    }
    else
    {
        cout << "不能调用可以调用join()或者detach()" << endl;
    }
    cout<<"asfafafsdfsadfsdafsdf11111"<<endl;// 主线程在执行，从main()返回，整个进程执行结束
    cout<<"asfafafsdfsadfsdafsdf22222"<<endl;// 主线程在执行，从main()返回，整个进程执行结束
    cout<<"asfafafsdfsadfsdafsdf33333"<<endl;// 主线程在执行，从main()返回，整个进程执行结束
    cout<<"asfafafsdfsadfsdafsdf44444"<<endl;// 主线程在执行，从main()返回，整个进程执行结束
    cout<<"asfafafsdfsadfsdafsdf445555"<<endl;// 主线程在执行，从main()返回，整个进程执行结束
    cout<<"asfafafsdfsadfsdafsdf666666"<<endl;// 主线程在执行，从main()返回，整个进程执行结束
    return 0;
}

1.3 其他的创建线程的方式

（1）创建一个类，并编写圆括号重载函数，初始化一个该类的对象，把该对象作为线程入口地址

#include "bits/stdc++.h"
#include "thread"
using namespace std;
//自己创建的线程要从一个函数开始运行的。


class  TA{
public:
    void operator()(){// 不能带参数
        cout<<"我的线程operator开始执行了"<<endl;
        cout<<"我的线程operator执行结束了"<<endl;
    }
};
int main(){
    TA ta;
    thread mythread(ta);  //ta  是可调用对象的
    mythread.detach();
    cout<<"主线程执行结束"<<endl;
    return 0;
}

• 下面的写法 mi是一个引用，会出现问题，因为可能detach之后主线程结束，mi引用的主线程里边的局部变量，当主线程结束之后，局部变量会被释放，所以会出现问题的。
• 使用detach之后，主线程结束，那么使用的ta对象还在吗 ？（对象不在了），对象实际上是被复制到线程中（复制了一个新对象的）。执行主线程，ta会被销毁，复制对象还在的，只要没有引用，指针指向原来的地址，就不会出错。（可以使用构造函数和析构函数证明的，这里懒得写代码了）

#include "bits/stdc++.h"
#include "thread"
using namespace std;
//自己创建的线程要从一个函数开始运行的。


class  TA{
public:
    int & mi;
    TA(int &i):mi(i){ }
    void operator()(){// 不能带参数
        cout<<"我的线程operator开始执行了"<<endl;
        cout<<"我的线程operator执行结束了"<<endl;
        cout<<"mi的数值为"<<mi<<endl;

    }
};
int main(){

    int mi = 6;
    TA ta(mi);

    thread mythread(ta);  //ta  是可调用对象的
    mythread.detach();
    cout<<"主线程执行结束"<<endl;
    return 0;
}

（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是不会代表引用的，会被当成取地址
    thread oneobj(&Data_::SaveMsh,&s);
    thread twoobj(&Data_::GetMsg,&s);
    oneobj.join();
    twoobj.join();