C++ 多线程学习

看了很多优秀博文，做了一下补充和学习，参考的博文放在下面：
    一文详解C++多线程
    C++快速讲解（十）：线程
    c++11线程池实现
    C++之多线程编程
    C++线程池简单实现

多线程

   传统的C++（在C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统提供的API，比如Linux的<pthread.h>或者Windows下的<Windows.h>。
   C++11提供了语言层面上的多线程，包含在头文件的中，它解决了跨平台的问题，提供了管理线程、保护共享资源、线程间同步操作、原子操作等类。C++11新标准中引入了5个头文件来支持多线程编程，如下图：

1. 创建线程

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

void show(){
   
    for (int i = 0; i < 10; ++i) {
   
        cout<<"i:"<<i<<endl;
    }
}
int main() {
   
    thread t(show);
    cout<<"run main"<<endl;
    return 0;
}

注：线程只能被move()，不能被赋值。如 thread t2 = t1; 是错的   thread t2 = move(t1);是对的

2. join 和 detach

当线程启动后，一定要在线程相关联的thread销毁前，确定以何种方式等待进程结束。

• join方式：等待启动的线程完成，才会继续往下执行。
• detach方式：启动的线程自主在后台运行，当前的代码继续往下执行，不等待新进程结束。
• 可以使用joinable判断父子进程是否处于关联状态(转到2.3)。

2.1 join

  join的意思是让主线程等待子进程执行结束后再进行下一步，就是让主线程挂起。

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

void show(){
   
    for (int i = 0; i < 10; ++i) {
   
        cout<<"i:"<<i<<endl;
        sleep(1); //这里单位是s  或者使用<Windows.h>里的SLeep(25)函数，这里的单位是ms
    }
}
int main() {
   
    thread t(show) ;

    //让主线程等待子线程运行结束后，再继续下面的逻辑
    //否则主线程运行结束，程序就结束了。
    t.join();
    cout << "run main" <<endl;
    return 0;
}

2.2 detach

  detach的意思是将本线程从调用线程中分离出来，允许本线程独立执行，也就是说两个线程同时运行，当主线程结束的时候，进程结束。
  那这样不就中断了子线程的运行吗？
  其实不是，在detach的时候，这个子线程将脱离主线程的控制，子线程独立分离出去并在后台运行，相当于linux中的守护进程，那么该子线程会由运行时库托管。当主线程结束的时候，进程也就结束，那么该进程的所有线程也会结束，被分离出去的子线程会由运行时库回收其资源。

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

void show(){
   
    for (int i = 0; i < 10; ++i) {
   
        cout<<"i:"<<i<<endl;
        sleep(1);
    }
}
int main() {
   
    thread t(show) ;
    t.detach();
    sleep(3);
    cout << "run main" <<endl;
    return 0;
}

    主线程在3s后结束，这里注意：（如果有其它子线程）守护线程会在主线程结束之后等待其他子线程的结束才会结束，（没有其他子线程）主线程结束，守护线程随之结束。
    与守护进程的区别：守护进程执行完自己的代码后不会立即结束，而是等待子进程结束后，回收子进程资源。

2.3 joinable

    joinable()函数用于判断主线程和子线程是否处于关联(连接)状态，一般情况下，二者之间的关系处于关联状态，该函数返回一个布尔类型值。

• 返回值类型为true：主线程和子线程之间有关联(连接)关系。
• 返回值类型为false：主线程和子线程之间没有关联(连接)关系。

举例：

#include <iostream>
#include <thread>
using namespace std;
 
void show() {
   
    cout<<"run myThread"<<endl;
}
 
int main() 
{
   
    thread t1;
    cout << "before starting, joinable: " << t1.joinable() << endl;
 
    t1 = thread(show);
    cout << "after starting, joinable: " << t1.joinable() << endl;
 
    t1.join();
    cout << "after joining, joinable: " << t1.joinable() << endl;
 
    thread t2(show);
    cout << "after starting, joinable: " << t2.joinable() << endl;
    
    t2.detach();
    cout << "after detaching, joinable: " << t2.joinable() << endl;
}

结果返回：0 1 0 1 0
结论：

• 在创建子线程对象的时候，如果没有指定任务函数，那么子线程不会启动，主线程和这个子线程就不进行连接。
• 在创建子线程对象的时候，如果指定了任务函数，子线程启动并执行任务，主线程和这个子线程自动连接（如t2)。
• 子线程调用了detach()函数之后，父子线程分离，同时二者的连接断开，调用joinable()返回false。
• 在子线程调用了join()函数之后，子线程中的任务函数继续执行，直到任务处理完毕，这是join()会清理（回收）当前子线程的相关资源，所以这个子线程和主线程的连接也就断开了，因此，调用join()之后再调用joinable()会返回false。

    或者可以这么理解joinable()函数：它是一个布尔类型函数，会返回一个布尔值来表示当前线程是否是可执行线程（能被join或者detach），因为相同的线程不能join两次，同理也不能detach两次，也不能join完再detach，所以joinable函数就是用来判断当前这个线程是否可以joinable的。通常不能被joinable有以下几种情况：
    1. 由thread的缺省构造函数而造成（thread() 没有参数）
    2. 该thread被move过（包括move构造和move赋值，待学习）
    3. 该线程被join或者detach过

3. 传递参数

  在线程里面执行的函数传递参数，最常使用的方法就是bind机制。

#include <iostream>
#include <thread>
#include <functional> //记得加上相关库文件
using namespace std;

void show(int n, string str){
   
    for (int i = 0; i < n; ++i) {
   
        cout<<i<<": "<<str