6.2创建线程的方法，join，detach、joinable、其它创建线程的方法

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

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

整个进程是否执行完毕的标志是主线程是否执行完，如果主线程执行完毕了，就代表整个进程执行完毕了！

此时，一般情况下：如果其他子线程还没有执行完毕，那么这些子线程也会被操作系统强行终止。

所以，得到一个结论：如果想保持子线程（自己用代码创建的线程）的运行状态的话，那么要让主线程一直保持运行，不要让主线程运行完毕。

[这条规则也有例外，后续会解这种例外，目前先这样理解和记忆]

编写多线程程序条件：

a)包含一个头文件<thread>

b)初始函数。

c)main中创建子线程

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

1.1 thread：标准库里的类

 join（）

加入/汇合，说白了就是阻塞，阻塞主线程，让主线程等待子线程执行完毕，子线程和主线程汇合，然后主线程再往下走！

如果主线程执行完毕了，但子线程没执行完毕，这种程序不台格的；

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

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

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

    cout <<"我的线程执行完毕了" <<endl;
}
int main()
{
  
   thread mytobj(mythread);

   thread就是一个类，参数是课调用对象
   创建了线程，创建完之后mythread就开始执行了

   mytobj.join();
   //如果没这一条语句就会执行混乱。互相穿插
   join就是阻塞的意思，阻塞主线程，让主线程等待子线程执行完毕。
   子线程执行完毕，主线程就开始继续执行。
   
   //易出现的错误：
   如果没有join（） 主线程执行完毕，子线程还没执行完就会出现错误。

   cout <<"I love China!" <<endl;

}

detach（）

传统多线程程序主线程要等待子线程执行完毕，然后自己再最后退出；

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

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

一旦detach()之后，与这个主线程关联的thread对象就会失去与这个主线程的关联，此时这个子线程就会驻留在后台运行（主线程与子线程失去联系）

这个子线程就相当于被C++运行时库接管，当这个子线程执行完成后，由运行时库负责清理该线程相关的资源（守护线程）

detach()使线程去自己的控制。

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

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

    cout <<"我的线程执行完毕了" <<endl;
}
int main()
{
   //传统的就是让主线程等待子线程指向完毕。

   detach（）：分离：主线程不必等待子线程了，主线程执行完毕就结束，子线程执行完毕
   自己就结束。建议：还是主线程等待子线程比较好

   thread mytobj(mythread);

   mytobj.detach();

   一旦detach()之后：两线程就会分离。就成了系统后台来处理。
   可以打开资源管理器来观看。
   cout <<"I love China!" <<endl;
}

主线程执行完毕了，子线程由后台接管了

joinable（）

判断是否可以使用join()或者detach()的；返回true(可以join或者detach）。

如果join了就不能再detach了。这两个要分开。

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

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

    cout <<"我的线程执行完毕了" <<endl;
}
int main()
{
   //joinable(): 判断是否可以成功使用join() 或者 detach()
   //返回true(可以join或者detach)false（则不能）
   thread mytobj(mythread);
   if(mytobj.joinable())
   {
      cout<<"joinable() == true" << endl;
      mytobj.join();
      cout <<"join is ok" <<endl;
   }
   else
   {
       cout<<"joinable() == false" <<endl;
   }

      if(mytobj.joinable())
   {
      cout<<"joinable() == true" <<endl;
   }
   else
   {
       cout<<"joinable() == false" <<endl;
   }

   cout <<"I love China!" <<endl;
}

可以看这个结果，如果处理不好进程与线程的关系，非常容易出现问题。

其它创建线程的方法

方法一：使用类对象

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

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

方法二：    用lambda表达式

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

    auto mylamthread = []{
        cout<< "我的线程开始执行了" << endl;
        cout<< "我的线程......" << endl;
        cout<< "我的线程开始结束了" << endl;
    };

int main()
{

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

    cout <<"I Love China"<<endl;
    return 0;

}

易出现的问题

 

一个疑问：一旦调用了detach(),那我主线程执行结束了，这里用的这个ta对象还在吗？（对象不在了）

解释：实际上这个对象是被 复制 到线程中去；执行完主线程后，ta会被销毁，但是所复制的TA对象依旧存在，所以只要这个Ta类对象没有引用，没有指针，那么就不会产生问题。

所以，如果使用的是detach(),那么就要考虑到变量的声明周期。

1.首先，看这个int myi =1; 这个值，如果使用detach（），主线程结束，子线程还在执行，myi被m_i绑定，myi释放，子线程还在执行就会出错。

2. 注意这个拷贝构造函数的构造和析构的时机，这样就可以脱离与主线程的关系。

#include <iostream>
#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;
    }
    void operator()()//不能带参数
    {
        cout<<"m_i的值为："<<m_i<<endl;
        cout<<"m_i的值为："<<m_i<<endl;
        cout<<"m_i的值为："<<m_i<<endl;
        cout<<"m_i的值为："<<m_i<<endl;
        cout<<"m_i的值为："<<m_i<<endl;
        cout<<"m_i的值为："<<m_i<<endl;
    }
    ~TA()
    {
        cout << "析构函数执行了" << endl;
    }
};
int main()
{

    int myi = 1;
    TA ta(myi);//构造函数
    thread mythread(ta);
    mythread.join();
    //还有一个问题：主线程结束ta销毁， thread mythread(ta); 这里是复制到线程中去了，所以执行完之后
    //子线程中还依旧存在复制的ta。
    cout <<"I Love China"<<endl;
    return 0;
}