线程启动、结束、创建线程多个方法，join和detach

一.线程运行的开始和结束

主线程从main()函数开始执行，因此我们自己创建的线程，也需要从一个函数函数开始运行(初始函数)，一旦这个函数执行完毕，就代表我们的线程运行结束。

整个进程是否执行完毕的标记：主线程是否执行完毕。

一般情况下，如果主线程运行完毕，而子线程还没运行完成，则这些子线程就会被操作系统强行终止，因此如果想保持子线程的运行状态的话，就要让主线程一直保持运行。—>这个有例外，之后会解释特殊情况。

大家必须明确一点：有两个线程在跑，相当于整个程序的执行有两条线在同时走，所以，可以同时干两个事，即使一条线被堵住了，另外一条线是可以通行的，这就是多线程。

1.thread 标准库中的类

2.join()

阻塞主线程，让主线程等待子线程执行完毕，然后子线程和主线程会和，然后主线程继续运行。

如果主线程执行完毕，而子线程还没有执行完毕，程序会有异常。

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

#include <bits/stdc++.h>
#include <thread>
using namespace std;

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

int main(){
    thread myThread(myPrint); //1)创建了线程，线程入口是myPrint 2)myPrint线程开始执行
    myThread.join(); //阻塞主线程，并等待子线程执行完毕

    cout<<"I love China"<<endl;
    return 0;
}
           

3.detach()

传统的多线程程序，主线程要等待子线程执行完毕，自己才最后退出。

主线程不和子线程汇合，主线程可以先执行完毕，不会影响到子线程。

为什么引入了datach？

我们创建了很多子线程，让主线程逐个等待子线程结束，这种编程方法不太好，所以引入了detach()。

一旦detach之后，与主线程关联的thread对象就会失去和主线程的联系，此时这个子线程就会驻留在后台运行(主线程和子线程失去联系)；子线程相当于被C++运行时库接管，当这个子线程执行完毕后，由运行时库负责清理该线程相关的资源（守护线程)。

#include <bits/stdc++.h>
#include <thread>
using namespace std;

void myPrint(){
    cout<<"我的线程开始执行"<<endl;
    cout<<"我的线程执行完毕1"<<endl;
    cout<<"我的线程执行完毕2"<<endl;
    cout<<"我的线程执行完毕3"<<endl;
    cout<<"我的线程执行完毕4"<<endl;
    cout<<"我的线程执行完毕5"<<endl;
    cout<<"我的线程执行完毕6"<<endl;
}

int main(){
    thread myThread(myPrint); //1)创建了线程，线程入口是myPrint 2)myPrint线程开始执行
    myThread.detach();

    cout<<"I love China 1"<<endl;
    cout<<"I love China 2"<<endl;
    cout<<"I love China 3"<<endl;
    cout<<"I love China 4"<<endl;
    return 0;
}
           

上面的程序有可能会输出下列的结果，子线程只会输出两句，并没有全部输出。这是因此此时主线程已经结束了，即这个进程也结束了，detach之后子进程是在后台运行的，因此当主线程还没有结束的时候，可以看到子线程的输出，而当主线程结束了之后，看不到了子线程的输出，但是子线程还是会执行完毕的。

I love China 1
I love China 2
I love China 3
I love China 4
我的线程开始执行
我的线程执行完毕1
           

一旦调用了detach之后，不能再join，大部分是用join。

4.joinable()

判断是否可以成功使用join或者detach，返回true(可以join或者detach)，返回false(不可以join或者detach)。

二.其他创建线程的手法

1.用类、以及一个问题范例

第一个问题：TA类中的数据是引用类型，调用了detach之后，主线程执行完之后，myi的内存就会被回收，而在子线程中还在打印这片内存中的内容，就会产生不可预料的结果。

解法方法：1）使用join 2）TA类中不要使用引用，使用值传递

第二个问题：调用了detach，当主线程结束了之后，TA对象被销毁了，那子线程还能使用这个对象的成员函数吗？

实际上这个TA对象是被复制到了子线程中，执行完主线程之后，TA对象被销毁，但是所复制的TA对象仍然还在。

#include <bits/stdc++.h>
#include <thread>
using namespace std;

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<<"m_i的值为："<<m_i<<endl;
    }
};
int main(){
    int myi = 6;
    TA ta(myi);
    thread p(ta); //ta：可调用对象
    //p.join();
    p.detach();
    cout<<"I love China"<<endl;
    return 0;
}
           

p.join()的运行结果，为什么会有两次拷贝构造呢？我也不太清楚，我猜是会生成一个中间变量。

TA 构造函数被执行
TA 拷贝构造函数被执行
TA 拷贝构造函数被执行
TA 析构函数被执行
m_i的值为：6
TA 析构函数被执行
I love China
TA 析构函数被执行
           

2.用lambda表达式

#include <bits/stdc++.h>
#include <thread>
using namespace std;


int main(){
    auto mylamthread = [] {
        cout<<"线程开始执行"<<endl;
         cout<<"线程执行完毕"<<endl;
    };
    thread p(mylamthread);
    p.join();
    cout<<"I love China"<<endl;
    return 0;
}
           

lambda表达式

[外部变量访问方式说明符] (参数表) -> 返回值类型
{
   语句块
}
           

其中，“外部变量访问方式说明符”可以是=或&，表示{}中用到的、定义在{}外面的变量在{}中是否允许被改变。=表示不允许，&表示允许。当然，在{}中也可以不使用定义在外面的变量。“-> 返回值类型”可以省略。