参考链接

c版本

1、线程概述

线程是轻量级的进程（LWP：light weight process），在Linux环境下线程的本质仍是进程。在计算机上运行的程序是一组指令及指令参数的组合，指令按照既定的逻辑控制计算机运行。操作系统会以进程为单位，分配系统资源，可以这样理解，进程是资源分配的最小单位，线程是操作系统调度执行的最小单位。

• 进程有自己独立的地址空间, 多个线程共用同一个地址空间

  • 线程更加节省系统资源, 效率不仅可以保持的, 而且能够更高
  • 在一个地址空间中多个线程独享: 每个线程都有属于自己的栈区, 寄存器(内核中管理的)
  • 在一个地址空间中多个线程共享: 代码段, 堆区, 全局数据区, 打开的文件(文件描述符表)都是线程共享的

• 线程是程序的最小执行单位, 进程是操作系统中最小的资源分配单位

  • 每个进程对应一个虚拟地址空间，一个进程只能抢一个CPU时间片
  • 一个地址空间中可以划分出多个线程, 在有效的资源基础上, 能够抢更多的CPU时间片

• CPU的调度和切换: 线程的上下文切换比进程要快的多
  上下文切换：进程/线程分时复用CPU时间片，在切换之前会将上一个任务的状态进行保存, 下次切换回这个任务的时候, 加载这个状态继续运行，任务从保存到再次加载这个过程就是一次上下文切换。

• 线程更加廉价, 启动速度更快, 退出也快, 对系统资源的冲击小。

在处理多任务程序的时候使用多线程比使用多进程要更有优势，但是线程并不是越多越好，如何控制线程的个数呢？

1. 文件IO操作：文件IO对CPU是使用率不高, 因此可以分时复用CPU时间片, 线程的个数 = 2 * CPU核心数 (效率最高)

2. 处理复杂的算法(主要是CPU进行运算, 压力大)，线程的个数 = CPU的核心数 (效率最高)

2、创建线程

每一个线程都有一个唯一的线程ID，ID类型为pthread_t，这个ID是一个无符号长整形数，如果想要得到当前线程的线程ID，可以调用如下函数：

pthread_t pthread_self(void);	// 返回当前线程的线程ID

在一个进程中调用线程创建函数，就可得到一个子线程，和进程不同，需要给每一个创建出的线程指定一个处理函数，否则这个线程无法工作。

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
// Compile and link with -pthread, 线程库的名字叫pthread, 全名: libpthread.so libpthread.a

• 参数:

  • thread: 传出参数，是无符号长整形数，线程创建成功, 会将线程ID写入到这个指针指向的内存中
  • attr: 线程的属性, 一般情况下使用默认属性即可, 写NULL
  • start_routine: 函数指针，创建出的子线程的处理动作，也就是该函数在子线程中执行。
  • arg: 作为实参传递到 start_routine 指针指向的函数内部

• 返回值：线程创建成功返回0，创建失败返回对应的错误号

下面是创建线程的示例代码，在创建过程中一定要保证编写的线程函数与规定的函数指针类型一致：void *(*start_routine) (void *):

// pthread_create.c 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>// 子线程的处理代码
void* working(void* arg)
{printf("我是子线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<9; ++i){printf("child == i: = %d\n", i);}return NULL;
}int main()
{// 1. 创建一个子线程pthread_t tid;pthread_create(&tid, NULL, working, NULL);printf("子线程创建成功, 线程ID: %ld\n", tid);// 2. 子线程不会执行下边的代码, 主线程执行printf("我是主线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<3; ++i){printf("i = %d\n", i);}// 休息, 休息一会儿...// sleep(1);return 0;
}

编译输出

子线程创建成功, 线程ID: 139712560109312
我是主线程, 线程ID: 139712568477440
i = 0
i = 1
i = 2

在打印的日志输出中为什么子线程处理函数没有执行完毕呢（只看到了子线程的部分日志输出）？
主线程一直在运行, 执行期间创建出了子线程，说明主线程有CPU时间片, 在这个时间片内将代码执行完毕了, 主线程就退出了。子线程被创建出来之后需要抢cpu时间片, 抢不到就不能运行，如果主线程退出了, 虚拟地址空间就被释放了, 子线程就一并被销毁了。但是如果某一个子线程退出了, 主线程仍在运行, 虚拟地址空间依旧存在。

得到的结论：在没有人为干预的情况下，虚拟地址空间的生命周期和主线程是一样的，与子线程无关。

目前的解决方案: 让子线程执行完毕, 主线程再退出, 可以在主线程中添加挂起函数 sleep();

3、线程退出

在编写多线程程序的时候，如果想要让线程退出，但是不会导致虚拟地址空间的释放（针对于主线程），我们就可以调用线程库中的线程退出函数，只要调用该函数当前线程就马上退出了，并且不会影响到其他线程的正常运行，不管是在子线程或者主线程中都可以使用。

#include <pthread.h>
void pthread_exit(void *retval);

• 参数: 线程退出的时候携带的数据，当前子线程的主线程会得到该数据。如果不需要使用，指定为NULL

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>// 子线程的处理代码
void* working(void* arg)
{sleep(1);printf("我是子线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<9; ++i){if(i==6){pthread_exit(NULL);	// 直接退出子线程} printf("child == i: = %d\n", i);}return NULL;
}int main()
{// 1. 创建一个子线程pthread_t tid;pthread_create(&tid, NULL, working, NULL);printf("子线程创建成功, 线程ID: %ld\n", tid);// 2. 子线程不会执行下边的代码, 主线程执行printf("我是主线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<3; ++i){printf("i = %d\n", i);}// 主线程调用退出函数退出, 地址空间不会被释放pthread_exit(NULL);return 0;
}

4、线程回收

线程和进程一样，子线程退出的时候其内核资源主要由主线程回收，线程库中提供的线程回收函叫做pthread_join()，这个函数是一个阻塞函数，如果还有子线程在运行，调用该函数就会阻塞，子线程退出函数解除阻塞进行资源的回收，函数被调用一次，只能回收一个子线程，如果有多个子线程则需要循环进行回收。

#include <pthread.h>
// 这是一个阻塞函数, 子线程在运行这个函数就阻塞
// 子线程退出, 函数解除阻塞, 回收对应的子线程资源, 类似于回收进程使用的函数 wait()
int pthread_join(pthread_t thread, void **retval);

• thread: 要被回收的子线程的线程ID
• retval: 二级指针, 指向一级指针的地址, 是一个传出参数, 这个地址中存储了pthread_exit() 传递出的数据，如果不需要这个参数，可以指定为NULL

返回值：线程回收成功返回0，回收失败返回错误号。

使用子线程栈

通过函数pthread_exit(void *retval);可以得知，子线程退出的时候，需要将数据记录到一块内存中，通过参数传出的是存储数据的内存的地址，而不是具体数据，由因为参数是void*类型，所有这个万能指针可以指向任意类型的内存地址。先来看第一种方式，将子线程退出数据保存在子线程自己的栈区：

// pthread_join.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>// 定义结构
struct Persion
{int id;char name[36];int age;
};// 子线程的处理代码
void* working(void* arg)
{printf("我是子线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<9; ++i){printf("child == i: = %d\n", i);if(i == 6){struct Persion p;p.age  =12;strcpy(p.name, "tom");p.id = 100;// 该函数的参数将这个地址传递给了主线程的pthread_join()pthread_exit(&p);}}return NULL;	// 代码执行不到这个位置就退出了
}int main()
{// 1. 创建一个子线程pthread_t tid;pthread_create(&tid, NULL, working, NULL);printf("子线程创建成功, 线程ID: %ld\n", tid);// 2. 子线程不会执行下边的代码, 主线程执行printf("我是主线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<3; ++i){printf("i = %d\n", i);}// 阻塞等待子线程退出void* ptr = NULL;// ptr是一个传出参数, 在函数内部让这个指针指向一块有效内存// 这个内存地址就是pthread_exit() 参数指向的内存pthread_join(tid, &ptr);// 打印信息struct Persion* pp = (struct Persion*)ptr;printf("子线程返回数据: name: %s, age: %d, id: %d\n", pp->name, pp->age, pp->id);printf("子线程资源被成功回收...\n");return 0;
}

输出

子线程创建成功, 线程ID: 139726224881216
我是主线程, 线程ID: 139726229210944
i = 0
i = 1
i = 2
我是子线程, 线程ID: 139726224881216
child == i: = 0
child == i: = 1
child == i: = 2
child == i: = 3
child == i: = 4
child == i: = 5
child == i: = 6
子线程返回数据: name: , age: -1946159552, id: -2080370016
子线程资源被成功回收...

通过打印的日志可以发现，在主线程中没有没有得到子线程返回的数据信息，具体原因是这样的：

如果多个线程共用同一个虚拟地址空间，每个线程在栈区都有一块属于自己的内存，相当于栈区被这几个线程平分了，当线程退出，线程在栈区的内存也就被回收了，因此随着子线程的退出，写入到栈区的数据也就被释放了。

使用全局变量

位于同一虚拟地址空间中的线程，虽然不能共享栈区数据，但是可以共享全局数据区和堆区数据，因此在子线程退出的时候可以将传出数据存储到全局变量、静态变量或者堆内存中。在下面的例子中将数据存储到了全局变量中：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>// 定义结构
struct Persion
{int id;char name[36];int age;
};struct Persion p;	// 定义全局变量// 子线程的处理代码
void* working(void* arg)
{printf("我是子线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<9; ++i){printf("child == i: = %d\n", i);if(i == 6){// 使用全局变量p.age  =12;strcpy(p.name, "tom");p.id = 100;// 该函数的参数将这个地址传递给了主线程的pthread_join()pthread_exit(&p);}}return NULL;
}int main()
{// 1. 创建一个子线程pthread_t tid;pthread_create(&tid, NULL, working, NULL);printf("子线程创建成功, 线程ID: %ld\n", tid);// 2. 子线程不会执行下边的代码, 主线程执行printf("我是主线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<3; ++i){printf("i = %d\n", i);}// 阻塞等待子线程退出void* ptr = NULL;// ptr是一个传出参数, 在函数内部让这个指针指向一块有效内存// 这个内存地址就是pthread_exit() 参数指向的内存pthread_join(tid, &ptr);// 打印信息struct Persion* pp = (struct Persion*)ptr;printf("name: %s, age: %d, id: %d\n", pp->name, pp->age, pp->id);printf("子线程资源被成功回收...\n");return 0;
}

输出

子线程创建成功, 线程ID: 139960019580480
我是主线程, 线程ID: 139960023627584
i = 0
i = 1
i = 2
我是子线程, 线程ID: 139960019580480
child == i: = 0
child == i: = 1
child == i: = 2
child == i: = 3
child == i: = 4
child == i: = 5
child == i: = 6
name: tom, age: 12, id: 100
子线程资源被成功回收...

使用主线程栈

虽然每个线程都有属于自己的栈区空间，但是位于同一个地址空间的多个线程是可以相互访问对方的栈空间上的数据的。由于很多情况下还需要在主线程中回收子线程资源，所以主线程一般都是最后退出，基于这个原因在下面的程序中将子线程返回的数据保存到了主线程的栈区内存中：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>// 定义结构
struct Persion
{int id;char name[36];int age;
};// 子线程的处理代码
void *working(void *arg)
{struct Persion *p = (struct Persion *)arg;printf("我是子线程, 线程ID: %ld\n", pthread_self());for (int i = 0; i < 9; ++i){printf("child == i: = %d\n", i);if (i == 6){// 使用主线程的栈内存p->age = 12;strcpy(p->name, "tom");p->id = 100;// 该函数的参数将这个地址传递给了主线程的pthread_join()pthread_exit(p);}}return NULL;
}int main()
{// 1. 创建一个子线程pthread_t tid;struct Persion p;// 主线程的栈内存传递给子线程pthread_create(&tid, NULL, working, &p);printf("子线程创建成功, 线程ID: %ld\n", tid);// 2. 子线程不会执行下边的代码, 主线程执行printf("我是主线程, 线程ID: %ld\n", pthread_self());for (int i = 0; i < 3; ++i){printf("i = %d\n", i);}// 阻塞等待子线程退出void *ptr = NULL;// ptr是一个传出参数, 在函数内部让这个指针指向一块有效内存// 这个内存地址就是pthread_exit() 参数指向的内存pthread_join(tid, &ptr);// 打印信息struct Persion *pp = (struct Persion *)ptr;printf("name: %s, age: %d, id: %d\n", pp->name, pp->age, pp->id);printf("name: %s, age: %d, id: %d\n", p.name, p.age, p.id);printf("子线程资源被成功回收...\n");return 0;
}

子线程创建成功, 线程ID: 139755662603840
我是主线程, 线程ID: 139755665672000
i = 0
i = 1
i = 2
我是子线程, 线程ID: 139755662603840
child == i: = 0
child == i: = 1
child == i: = 2
child == i: = 3
child == i: = 4
child == i: = 5
child == i: = 6
name: tom, age: 12, id: 100
name: tom, age: 12, id: 100
子线程资源被成功回收...

在上面的程序中，调用pthread_create()创建子线程，并将主线程中栈空间变量p的地址传递到了子线程中，在子线程中将要传递出的数据写入到了这块内存中。也就是说在程序的main()函数中，通过指针变量ptr或者通过结构体变量p都可以读出子线程传出的数据。

5、线程分离

在某些情况下，程序中的主线程有属于自己的业务处理流程，如果让主线程负责子线程的资源回收，调用pthread_join()只要子线程不退出主线程就会一直被阻塞，主要线程的任务也就不能被执行了。

在线程库函数中为我们提供了线程分离函数pthread_detach()，调用这个函数之后指定的子线程就可以和主线程分离，当子线程退出的时候，其占用的内核资源就被系统的其他进程接管并回收了。线程分离之后在主线程中使用pthread_join()就回收不到子线程资源了。

#include <pthread.h>
// 参数就子线程的线程ID, 主线程就可以和这个子线程分离了
int pthread_detach(pthread_t thread);

下面的代码中，在主线程中创建子线程，并调用线程分离函数，实现了主线程和子线程的分离：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>// 子线程的处理代码
void* working(void* arg)
{printf("我是子线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<9; ++i){printf("child == i: = %d\n", i);}return NULL;
}int main()
{// 1. 创建一个子线程pthread_t tid;pthread_create(&tid, NULL, working, NULL);printf("子线程创建成功, 线程ID: %ld\n", tid);// 2. 子线程不会执行下边的代码, 主线程执行printf("我是主线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<3; ++i){printf("i = %d\n", i);}// 设置子线程和主线程分离pthread_detach(tid);// 让主线程自己退出即可pthread_exit(NULL);return 0;
}

6、其他线程函数

线程取消

线程取消的意思就是在某些特定情况下在一个线程中杀死另一个线程。使用这个函数杀死一个线程需要分两步：

• 在线程A中调用线程取消函数pthread_cancel，指定杀死线程B，这时候线程B是死不了的
• 在线程B中进程一次系统调用（从用户区切换到内核区），否则线程B可以一直运行。

这其实和七步断肠散、含笑半步癫的功效是一样的，吃了毒药不动或者不笑也没啥事儿

#include <pthread.h>
// 参数是子线程的线程ID
int pthread_cancel(pthread_t thread);

参数：要杀死的线程的线程ID
返回值：函数调用成功返回0，调用失败返回非0错误号。

在下面的示例代码中，主线程调用线程取消函数，只要在子线程中进行了系统调用，当子线程执行到这个位置就挂掉了。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>// 子线程的处理代码
void* working(void* arg)
{int j=0;for(int i=0; i<9; ++i){j++;}// 这个函数会调用系统函数, 因此这是个间接的系统调用printf("我是子线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<9; ++i){printf(" child i: %d\n", i);}return NULL;
}int main()
{// 1. 创建一个子线程pthread_t tid;pthread_create(&tid, NULL, working, NULL);printf("子线程创建成功, 线程ID: %ld\n", tid);// 2. 子线程不会执行下边的代码, 主线程执行printf("我是主线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<3; ++i){printf("i = %d\n", i);}// 杀死子线程, 如果子线程中做系统调用, 子线程就结束了pthread_cancel(tid);// 让主线程自己退出即可pthread_exit(NULL);return 0;
}

关于系统调用有两种方式：
1、直接调用Linux系统函数
2、调用标准C库函数，为了实现某些功能，在Linux平台下标准C库函数会调用相关的系统函数

6.2 线程ID比较

在Linux中线程ID本质就是一个无符号长整形，因此可以直接使用比较操作符比较两个线程的ID，但是线程库是可以跨平台使用的，在某些平台上 pthread_t可能不是一个单纯的整形，这中情况下比较两个线程的ID必须要使用比较函数，函数原型如下：

#include <pthread.h>
int pthread_equal(pthread_t t1, pthread_t t2);

参数：t1 和 t2 是要比较的线程的线程ID
返回值：如果两个线程ID相等返回非0值，如果不相等返回0

C++版本

C++11之前，C++语言没有对并发编程提供语言级别的支持，这使得我们在编写可移植的并发程序时，存在诸多的不便。现在C++11中增加了线程以及线程相关的类，很方便地支持了并发编程，使得编写的多线程程序的可移植性得到了很大的提高。

创建线程以后，要么join要么detach，必须选其一。

C++11中提供的线程类叫做std::thread，基于这个类创建一个新的线程非常的简单，只需要提供线程函数或者函数对象即可，并且可以同时指定线程函数的参数。我们首先来了解一下这个类提供的一些常用API：

1、构造函数

// ①
thread() noexcept;
// ②
thread( thread&& other ) noexcept;
// ③
template< class Function, class... Args >
explicit thread( Function&& f, Args&&... args );
// ④
thread( const thread& ) = delete;

• 构造函数①：默认构造函，构造一个线程对象，在这个线程中不执行任何处理动作

• 构造函数②：移动构造函数，将 other 的线程所有权转移给新的thread 对象。之后 other 不再表示执行线程。

• 构造函数③：创建线程对象，并在该线程中执行函数f中的业务逻辑，args是要传递给函数f的参数

  • 任务函数f的可选类型有很多，具体如下：

    • 普通函数，类成员函数，匿名函数，仿函数（这些都是可调用对象类型）
    • 可以是可调用对象包装器类型，也可以是使用绑定器绑定之后得到的类型（仿函数）

• 构造函数④：使用=delete显示删除拷贝构造, 不允许线程对象之间的拷贝

2、公共成员函数

2.1 get_id()

应用程序启动之后默认只有一个线程，这个线程一般称之为主线程或父线程，通过线程类创建出的线程一般称之为子线程，每个被创建出的线程实例都对应一个线程ID，这个ID是唯一的，可以通过这个ID来区分和识别各个已经存在的线程实例，这个获取线程ID的函数叫做get_id()，函数原型如下：

std::thread::id get_id() const noexcept;

示例程序如下

#include <iostream>
#include <thread>
#include <chrono>
using namespace std;void func(int num, string str)
{for (int i = 0; i < 10; ++i){cout << "子线程: i = " << i << "num: " << num << ", str: " << str << endl;}
}void func1()
{for (int i = 0; i < 10; ++i){cout << "子线程: i = " << i << endl;}
}int main()
{cout << "主线程的线程ID: " << this_thread::get_id() << endl;thread t(func, 520, "i love you");thread t1(func1);cout << "线程t 的线程ID: " << t.get_id() << endl;cout << "线程t1的线程ID: " << t1.get_id() << endl;
}

• thread t(func, 520, “i love you”);：创建了子线程对象t，func()函数会在这个子线程中运行
  • func()是一个回调函数，线程启动之后就会执行这个任务函数，程序猿只需要实现即可
  • func()的参数是通过thread的参数进行传递的，520,i love you都是调用func()需要的实参
  • 线程类的构造函数③是一个变参函数，因此无需担心线程任务函数的参数个数问题
  • 任务函数func()一般返回值指定为void，因为子线程在调用这个函数的时候不会处理其返回值
• thread t1(func1);：子线程对象t1中的任务函数func1()，没有参数，因此在线程构造函数中就无需指定了
• 通过线程对象调用get_id()就可以知道这个子线程的线程ID了，t.get_id()，t1.get_id()。

在上面的示例程序中有一个bug，在主线程中依次创建出两个子线程，打印两个子线程的线程ID，最后主线程执行完毕就退出了（主线程就是执行main()函数的那个线程）。默认情况下，主线程销毁时会将与其关联的两个子线程也一并销毁，但是这时有可能子线程中的任务还没有执行完毕，最后也就得不到我们想要的结果了。

上述代码执行完会提示

terminate called without an active exception
Aborted (core dumped)

important

当启动了一个线程（创建了一个thread对象）之后，在这个线程结束的时候（std::terminate()），我们如何去回收线程所使用的资源呢？thread库给我们两种选择：

• 加入式（join()）
• 分离式（detach()）

另外，我们必须要在线程对象销毁之前在二者之间作出选择，否则程序运行期间就会有bug产生。

2.2 join()

join()字面意思是连接一个线程，意味着主动地等待线程的终止（线程阻塞）。在某个线程中通过子线程对象调用join()函数，调用这个函数的线程被阻塞，但是子线程对象中的任务函数会继续执行，当任务执行完毕之后join()会清理当前子线程中的相关资源然后返回，同时，调用该函数的线程解除阻塞继续向下执行。

再次强调，我们一定要搞清楚这个函数阻塞的是哪一个线程，函数在哪个线程中被执行，那么函数就阻塞哪个线程。该函数的函数原型为void join()

有了这样一个线程阻塞函数之后，就可以解决在上面测试程序中的bug了，如果要阻塞主线程的执行，只需要在主线程中通过子线程对象调用这个方法即可，当调用这个方法的子线程对象中的任务函数执行完毕之后，主线程的阻塞也就随之解除了。修改之后的示例代码如下：

#include <iostream>
#include <thread>
#include <chrono>
using namespace std;void func(int num, string str)
{for (int i = 0; i < 10; ++i){cout << "子线程: i = " << i << "num: " << num << ", str: " << str << endl;}
}void func1()
{for (int i = 0; i < 10; ++i){cout << "子线程: i = " << i << endl;}
}int main()
{cout << "主线程的线程ID: " << this_thread::get_id() << endl;thread t(func, 520, "i love you");thread t1(func1);cout << "线程t 的线程ID: " << t.get_id() << endl;cout << "线程t1的线程ID: " << t1.get_id() << endl;t.join();t1.join();
}

一个例子

#include <iostream>
#include <thread>
#include <chrono>
using namespace std;void download1()
{// 模拟下载, 总共耗时500ms，阻塞线程500msthis_thread::sleep_for(chrono::milliseconds(500));cout << "子线程1: " << this_thread::get_id() << ", 找到历史正文...." << endl;
}void download2()
{// 模拟下载, 总共耗时300ms，阻塞线程300msthis_thread::sleep_for(chrono::milliseconds(300));cout << "子线程2: " << this_thread::get_id() << ", 找到历史正文...." << endl;
}void doSomething()
{cout << "集齐历史正文, 呼叫罗宾...." << endl;cout << "历史正文解析中...." << endl;cout << "起航，前往拉夫德尔...." << endl;cout << "找到OnePiece, 成为海贼王, 哈哈哈!!!" << endl;cout << "若干年后，草帽全员卒...." << endl;cout << "大海贼时代再次被开启...." << endl;
}int main()
{thread t1(download1);thread t2(download2);// 阻塞主线程，等待所有子线程任务执行完毕再继续向下执行t1.join();t2.join();doSomething();
}

2.3 detach()

detach()函数的作用是进行线程分离，分离主线程和创建出的子线程。在线程分离之后，主线程退出也会一并销毁创建出的所有子线程，在主线程退出之前，它可以脱离主线程继续独立的运行，任务执行完毕之后，这个子线程会自动释放自己占用的系统资源。（其实就是孩子翅膀硬了，和家里断绝关系，自己外出闯荡了，如果家里被诛九族还是会受牵连）。该函数函数原型为 void detach();

线程分离函数没有参数也没有返回值，只需要在线程成功之后，通过线程对象调用该函数即可，继续将上面的测试程序修改一下：

int main()
{cout << "主线程的线程ID: " << this_thread::get_id() << endl;thread t(func, 520, "i love you");thread t1(func1);cout << "线程t 的线程ID: " << t.get_id() << endl;cout << "线程t1的线程ID: " << t1.get_id() << endl;t.detach();t1.detach();// 让主线程休眠, 等待子线程执行完毕this_thread::sleep_for(chrono::seconds(5));
}

注意事项：线程分离函数detach()不会阻塞线程，子线程和主线程分离之后，在主线程中就不能再对这个子线程做任何控制了，比如：通过join()阻塞主线程等待子线程中的任务执行完毕，或者调用get_id()获取子线程的线程ID。有利就有弊，鱼和熊掌不可兼得，建议使用join()。

例子

#include <iostream>
#include <thread>
#include <chrono>
using namespace std;void func(int num, string str)
{for (int i = 0; i < 10; ++i){cout << "子线程: i = " << i << "num: "<< num << ", str: " << str << endl;}
}void func1()
{for (int i = 0; i < 10; ++i){cout << "子线程: i = " << i << endl;}
}int main()
{cout << "主线程的线程ID: " << this_thread::get_id() << endl;thread t(func, 520, "i love you");thread t1(func1);cout << "线程t 的线程ID: " << t.get_id() << endl;cout << "线程t1的线程ID: " << t1.get_id() << endl;t.detach();t1.detach();cout << "detach后----线程t 的线程ID: " << t.get_id() << endl;cout << "detach后----线程t1的线程ID: " << t1.get_id() << endl;
}---------------------------------------
主线程的线程ID: 140268454314944
线程t 的线程ID: 140268447725120
线程t1的线程ID: 140268439332416
detach后----线程t 的线程ID: thread::id of a non-executing thread
detach后----线程t1的线程ID: thread::id of a non-executing thread

个人理解：join和detach的区别，就是两者都是由主线程销毁的时候销毁所有子线程，但是detach的线程可以自己运行结束就释放资源。同时join会阻塞主线程，detach不会阻塞。

2.4 joinable()

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

bool joinable() const noexcept;

#include <iostream>
#include <thread>
#include <chrono>
using namespace std;void foo()
{this_thread::sleep_for(std::chrono::seconds(1));
}int main()
{thread t;cout << "before starting, joinable: " << t.joinable() << endl;t = thread(foo);cout << "after starting, joinable: " << t.joinable() << endl;t.join();cout << "after joining, joinable: " << t.joinable() << endl;thread t1(foo);cout << "after starting, joinable: " << t1.joinable() << endl;t1.detach();cout << "after detaching, joinable: " << t1.joinable() << endl;
}---------------------------------------
before starting, joinable: 0
after starting, joinable: 1
after joining, joinable: 0
after starting, joinable: 1
after detaching, joinable: 0

结论

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

2.5 operator()

线程中的资源是不能被复制的，因此通过=操作符进行赋值操作最终并不会得到两个完全相同的对象。

// move (1)	
thread& operator= (thread&& other) noexcept;
// copy [deleted] (2)	
thread& operator= (const other&) = delete;

通过以上=操作符的重载声明可以得知：

• 如果other是一个右值，会进行资源所有权的转移
• 如果other不是右值，禁止拷贝，该函数被显示删除（=delete），不可用

3、静态函数

thread线程类还提供了一个静态方法，用于获取当前计算机的CPU核心数，根据这个结果在程序中创建出数量相等的线程，每个线程独自占有一个CPU核心，这些线程就不用分时复用CPU时间片，此时程序的并发效率是最高的。

static unsigned hardware_concurrency() noexcept;

#include <iostream>
#include <thread>
using namespace std;int main()
{int num = thread::hardware_concurrency();cout << "CPU number: " << num << endl;
}

4、C++线程命名空间

在C++11中不仅添加了线程类，还添加了一个关于线程的命名空间std::this_thread，在这个命名空间中提供了四个公共的成员函数，通过这些成员函数就可以对当前线程进行相关的操作了。

4.1 get_id()

前面已经介绍过

4.2 sleep_for()

进程创建后一共有五种状态。

同样地线程被创建后也有这五种状态：创建态，就绪态，运行态，阻塞态(挂起态)，退出态(终止态) ，关于状态之间的转换是一样的，请参考进程，在此不再过多的赘述。

线程和进程的执行有很多相似之处，在计算机中启动的多个线程都需要占用CPU资源，但是CPU的个数是有限的并且每个CPU在同一时间点不能同时处理多个任务。为了能够实现并发处理，多个线程都是分时复用CPU时间片，快速的交替处理各个线程中的任务。因此多个线程之间需要争抢CPU时间片，抢到了就执行，抢不到则无法执行（因为默认所有的线程优先级都相同，内核也会从中调度，不会出现某个线程永远抢不到CPU时间片的情况）。

命名空间this_thread中提供了一个休眠函数sleep_for()，调用这个函数的线程会马上从运行态变成阻塞态并在这种状态下休眠一定的时长，因为阻塞态的线程已经让出了CPU资源，代码也不会被执行，所以线程休眠过程中对CPU来说没有任何负担。这个函数是函数原型如下，参数需要指定一个休眠时长，是一个时间段：

template <class Rep, class Period>void sleep_for (const chrono::duration<Rep,Period>& rel_time);

#include <iostream>
#include <thread>
#include <chrono>
using namespace std;void func()
{for (int i = 0; i < 10; ++i){this_thread::sleep_for(chrono::seconds(1));cout << "子线程: " << this_thread::get_id() << ", i = " << i << endl;}
}int main()
{thread t(func);t.join();
}

在func()函数的for循环中使用了this_thread::sleep_for(chrono::seconds(1));之后，每循环一次程序都会阻塞1秒钟，也就是说每隔1秒才会进行一次输出。需要注意的是：程序休眠完成之后，会从阻塞态重新变成就绪态，就绪态的线程需要再次争抢CPU时间片，抢到之后才会变成运行态，这时候程序才会继续向下运行。

4.3 sleep_until()

命名空间this_thread中提供了另一个休眠函数sleep_until()，和**sleep_for()**不同的是它的参数类型不一样

• sleep_until()：指定线程阻塞到某一个指定的时间点time_point类型，之后解除阻塞
• sleep_for()：指定线程阻塞一定的时间长度duration 类型，之后解除阻塞

template <class Clock, class Duration>void sleep_until (const chrono::time_point<Clock,Duration>& abs_time);

示例程序如下：

#include <iostream>
#include <thread>
#include <chrono>
using namespace std;void func()
{for (int i = 0; i < 10; ++i){// 获取当前系统时间点auto now = chrono::system_clock::now();// 时间间隔为2schrono::seconds sec(2);// 当前时间点之后休眠两秒this_thread::sleep_until(now + sec);cout << "子线程: " << this_thread::get_id() << ", i = " << i << endl;}
}int main()
{thread t(func);t.join();
}

**sleep_until()和sleep_for()**函数的功能是一样的，只不过前者是基于时间点去阻塞线程，后者是基于时间段去阻塞线程，项目开发过程中根据实际情况选择最优的解决方案即可。

4.4 yield()

命名空间this_thread中提供了一个非常绅士的函数yield()，在线程中调用这个函数之后，处于运行态的线程会主动让出自己已经抢到的CPU时间片，最终变为就绪态，这样其它的线程就有更大的概率能够抢到CPU时间片了。使用这个函数的时候需要注意一点，线程调用了yield()之后会主动放弃CPU资源，但是这个变为就绪态的线程会马上参与到下一轮CPU的抢夺战中，不排除它能继续抢到CPU时间片的情况，这是概率问题。

void yield() noexcept;

示例程序

#include <iostream>
#include <thread>
using namespace std;void func()
{for (int i = 0; i < 100000000000; ++i){cout << "子线程: " << this_thread::get_id() << ", i = " << i << endl;this_thread::yield();}
}int main()
{thread t(func);thread t1(func);t.join();t1.join();
}

在上面的程序中，执行func()中的for循环会占用大量的时间，在极端情况下，如果当前线程占用CPU资源不释放就会导致其他线程中的任务无法被处理，或者该线程每次都能抢到CPU时间片，导致其他线程中的任务没有机会被执行。解决方案就是每执行一次循环，让该线程主动放弃CPU资源，重新和其他线程再次抢夺CPU时间片，如果其他线程抢到了CPU时间片就可以执行相应的任务了。

结论：

• std::this_thread::yield() 的目的是避免一个线程长时间占用CPU资源，从而导致多线程处理性能下降

• std::this_thread::yield() 是让当前线程主动放弃了当前自己抢到的CPU资源，但是在下一轮还会继续抢