【Linux】多线程基础

文章目录

- - 1.线程的基本概念
  - - 1.1重定义进程
    - 1.2Linux下的线程
  - 2.多级页表
  - 3.线程VS进程
  - - 3.1线程的优缺点
    - 3.2线程异常
    - 3.3线程用途
    - 3.4线程与进程的关系
  - 4.线程控制
  - - 4.1线程创建
    - 4.2线程等待
    - 4.3进程终止
    - 4.4线程分离
  - 5.线程ID与线程结构

1.线程的基本概念

在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制"序列”
一切进程至少都有一个执行线程。也叫做单执行流进程。
线程在进程内部运行，本质是在进程地址空间内运行
在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化
透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流

创建一个进程，需要先向操作系统注册一个进程控制块(PCB)task_strcut、mm_struct、页表、物理地址空间和进程地址空间通过页表建立映射关系。

如果在创建进程”进程时“，只创建task_struct，与原先的父进程共享进程地址空间、页表等。

CPU调度执行流的时候是通过task_struct进行调度。也就是说每一个task_struct就是一个执行流。这样的一个执行流就被称为一个线程。也可以看出同一个进程的内部的线程，共享数据和代码。

1.1重定义进程

进程根据执行流的数量，可以分为**单执行流进程和多执行流进程。**一个进程内部可能有多个线(执行流)

因此，所谓的进程并不是通过task_struct来衡量的，除了task_struct之外，一个进程还要有进程地址空间、文件、信号等等，合起来称之为一个进程。

进程的示意图

操作系统以进程未单位分配资源，因此进程是承担系统资源的基本实体
CPU通过task_struct调度执行流，因此线程是CPU调度的基本单位

1.2Linux下的线程

Linux系统中，CPU如何识别当前调度的task_struct是一个进程还是线程？

在操作系统的书上，将管理线程的结构体叫做TCB，与之相对的是进程管理模块PCB；
但是在Linux操作系统中，并没有区分进程和线程的概念，而是将一个一个task_struct调度视作为执行流。
在Linux中，都使用task_struct管理所谓的线程和进程。

执行一个线程时，就是执行单执行流的调度。

**执行一个进程时，**执行多执行流调度

如果一款操作系统要支持真的线程，那么就需要对这些线程进行管理。比如说创建线程、终止线程、调度线程、切换线程、给线程分配资源、释放资源以及回收资源等等，搭建一套与进程平行的线程管理模块。

如果要支持线程一定会提高操作系统的设计复杂程度。在Linux设计者看来，描述线程TCB和进程的PCB是类似的，因此Linux并没有重新为线程设计数据结构，而是直接复用了进程控制块，所以我们说Linux中的所有执行流都叫做轻量级进程。

Linux如何支持创建线程？

Linux没有真正意义上的线程，因此也没有线程相关的系统调用。但是Linux提供了一个创建轻量级进程的接口vfork,可以通过该接口创建一个轻量级的进程模拟线程。

pid_t vfork(void);

vfork函数的作用：创建子进程，但是父子共享进程地址空间

**返回值：**和fork函数的返回值相同，给父进程返回子进程PID，给子进程返回0。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main(){
    int val=100;
    int pid=vfork();
    if(pid==0){ //子进程
        val=200;
        printf("child fork pid=%d,ppid=%d,val=%d\n",getpid(),getppid(),val);
        exit(0);
    }
    sleep(2);
    printf("father fork pid=%d,ppid=%d,val=%d\n",getpid(),getppid(),val);
    return 0;
}

父子进程没有发生写时拷贝，说明了vfork创建的进程共享进程地址空间。

Linux的原生线程库pthread

为了程序员方便进行并发编程，Linux为用户提供了一个原生的线程库pthread。可以调用该动态库中的接口实现多线程编程。

#include <iostream>
#include <string>
#include <unistd.h>
#include <thread>
void thread_fun(int arg){
    int cnt=5;
    while (cnt--)
    {
        std::cout<<"我是新线程,arg="<<arg<<std::endl;
        sleep(1);
    }
}
int main(){
    std::thread t(thread_fun,10);
    t.join();
    return 0;
}

2.多级页表

32位的平台下，一共有2^{32个字节需要管理，也就意味着一共有2}32个地址需要通过页表映射管理

如果只是通过一张页表进行映射，假设页表的每一个条目(条目除了进程地址空间、物理地址还有一些访问权限等)为10字节，那么一共需要10*2^32个字节==40GB的空间对地址映射进行管理。

而在32位平台下我们的内存可能一共就只有4GB，也就是说我们根本无法存储这样的一张页表。

操作系统下的页表并不是一张简单的页表，而是多级页表结构。

一个32位的虚拟地址不是直接转化，而是按照10+10+12三部分进行转化。(后面会说明为什么分10+10+12三部分转化)
32位虚拟地址的前10位为一级页表的序号。
32位虚拟地址的中间10位位二级页表的序号，映射结果为物理内存单元页的起始地址。
32位虚拟地址的最后12位为页内偏移量。

物理内存的管理方式

1.物理内存按照页为管理单位进行管理。当内存和磁盘进行数据交换时也就是以4KB大小为单位进行加载和保存的。

2.4KB实际上就是2^{12个字节，而访问内存的基本大小是1字节，因此一个页中就有2}12个地址。

3.进程地址空间的中间10位映射到物理页的起始地址。而最后的12个比特位作为页内偏移量，从页的起始地址处开始向后进行偏移，从而找到物理内存中某一个对应字节数据。

二级页表结构图

所有映射过程，都是由MMU（MemoryManagementUnit）这个硬件完成的，该硬件是集成在CPU内的。页表是一种软件映射，MMU是一种硬件映射，所以计算机进行虚拟地址到物理地址的转化采用的是软硬件结合的方式。

在32位平台上采用的是二级页表机制，而在64位平台下采用的是多级页表机制。

3.线程VS进程

3.1线程的优缺点

优点

创建一个新线程的代价要比创建一个新进程小得多
与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多
线程占用的资源要比进程少很多
能充分利用多处理器的可并行数量
在等待慢速I/O操作结束的同时，程序可执行其他的计算任务
计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。

缺点

**性能损失：**一个很少被外部事件阻塞的计算密集型线程往往无法与共它线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。

**健壮性降低：**编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。

**缺乏访问控制：**进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。

编程难度提高：多线程程序比单线程程序更难编写

3.2线程异常

单个线程异常退出，整个进程也会退出
线程是进程的执行分支，线程出异常，就类似进程出异常，进而触发信号机制，终止进程，进程终止，该进程内的所有线程也就随即退出

3.3线程用途

合理的使用多线程，能提高CPU密集型程序的执行效率
合理的使用多线程，能提高IO密集型程序的用户体验。(比如我们可以一边在网上聊天，一边听歌)

3.4线程与进程的关系

线程与进程

线程是CPU调度的基本单位
进程是资源分配的基本单位
线程间共享进程数据，但是也拥有自己的线程数据：线程ID、一组寄存器、线程栈、errno、信号屏蔽字、调度优先级

进程中线程共享的数据有：

进程中定义的函数、全局变量、文件描述符、每种信号的处理方式、当前工作目录、用户ID和组ID

进程和线程的关系图

4.线程控制

POSIX线程库

pthread库是Linux提供给用户的应用层原生线程库：

应用层指的是这个线程库不是系统接口直接提供的，而是由第三方提供的。
原生指的是大部分Linux环境，都会默认带上该线程库。
与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的
要使用这些函数库，要通过引入头文件<pthreaad.h>。
链接这些线程函数库时，要使用编译器命令的“-lpthread”选项。

错误检查：

传统的POSIX函数是，成功返回0，失败返回-1.并设置全局变量errno
pthread库的函数出错时不会设置全局变量errno，而是将错误码通过返回值返回
pthreads同样也提供了线程内的errno变量，以支持其他使用errno的代码。对于pthreads函数的错误，建议通过返回值来判定，因为读取返回值要比读取线程内的errno变量的开销更小。

4.1线程创建

功能：创建一个新的线程。

函数原型：

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);

参数说明：

thread:传入类型参数，返回线程ID
attr:设置线程的属性，attr为NULL表示使用默认属性
start_routine:是个函数指针，线程启动后要执行的函数
arg:传给线程启动函数的参数

返回值说明：

成功返回0；失败返回错误码。

实例

void* routine(void* arg){
    char* msg=(char*)arg;
    while(1){
        std::cout<<"I am "<<msg<<std::endl;
        sleep(1);
    }

}
int main(){
    pthread_t tid;
    pthread_create(&tid,nullptr,routine,(void*)"routine1");
    while (1)
    {
        std::cout<<"I am main thread"<<std::endl;
        sleep(1);
    }
    return 0;
}

使用ps ajx指令查看当前进程信息，虽然我们运行了俩个线程，但是只能查看到一个进程信息，因为这两个线程属于同一个进程。

使用ps -aL指令，可以查看当前的轻量级进程。

可以看到俩个线程的进程PID相同，说明两个轻量级进程属于同一个进程；LWP(Light Weight Process)表示轻量级进程ID，在Linux中LWP与应用层线程一一对应。

在在Linux中，应用层的线程与内核的LWP是一一对应的，实际上操作系统调度的时候采用的是LWP，而并非PID。只不过在单执行流进程中，PID和LWP是相等的。

验证主线程创建的新线程属于同一个进程

使用getpid()和getppid()函数获取PID和PPID，对比各线程的PID和PPID是否相等。

#include <iostream>
#include <unistd.h>
#include <pthread.h>


void* routine(void* arg){
    char* msg=(char*)arg;
    while(1){
        std::cout<<"I am "<<msg<<"...pid:"<<getpid()<<"ppid:"<<getppid()<<std::endl;
        sleep(1);
    }

}
int main(){
    pthread_t tid[4];
    for(int i=0;i<5;i++){
        char* buf=(char*)malloc(64);
        sprintf(buf,"thread %d",i);
        pthread_create(&tid[i],nullptr,routine,buf);
    }
    while (1)
    {
        std::cout<<"I am main thread...pid:"<<getpid()<<"ppid:"<<getppid()<<std::endl;
        sleep(1);
    }
    return 0;
}

主线程和新线程的PID和PPID完全相同，说明所有线程属于是同一个进程。

获取线程ID

获取线程ID有两种方式，一种是在创建线程时传入的参数，第二种是使用pthread_self()获取当前线程id

void* routine(void* arg){
    char* msg=(char*)arg;
    while(1){
        std::cout<<"I am "<<msg<<"...pid:"<<getpid()<<"  ppid:"<<getppid()<<"  tid:"<<pthread_self()<<std::endl;
        sleep(1);
    }

}
int main(){
    pthread_t tid[4];
    for(int i=0;i<5;i++){
        char* buf=(char*)malloc(64);
        sprintf(buf,"thread %d",i);
        pthread_create(&tid[i],nullptr,routine,buf);
    }
    while (1)
    {
        std::cout<<"I am main thread...pid:"<<getpid()<<"  ppid:"<<getppid()<<"  tid:"<<pthread_self()<<std::endl;
        sleep(1);
    }
    return 0;
}

用pthread_self函数获得的线程ID与内核的LWP的值是不相等的，pthread_self函数获得的是用户级原生线程库的线程ID，而LWP是内核的轻量级进程ID，它们之间是一对一的关系。

获取LWP

使用syscalll和gettid()可以获取轻量级线程ID

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <sys/syscall.h>


void* routine(void* arg){
    char* msg=(char*)arg;
    while(1){
        std::cout<<"I am "<<msg<<"...pid:"<<getpid()<<"  ppid:"<<getppid()
        <<"  tid:"<<pthread_self()<<"  LWP:"<<::syscall(SYS_gettid)<<std::endl;
        sleep(1);
    }

}
int main(){
    pthread_t tid[4];
    for(int i=0;i<5;i++){
        char* buf=(char*)malloc(64);
        sprintf(buf,"thread %d",i);
        pthread_create(&tid[i],nullptr,routine,buf);
    }
    while (1)
    {
        std::cout<<"I am main thread...pid:"<<getpid()<<"  ppid:"<<getppid()
        <<"  tid:"<<pthread_self()<<"  LWP"<<::syscall(SYS_gettid)<<std::endl;
        sleep(1);
    }
    return 0;
}

每一个线程拥有一个LWP，内核调度时通过识别LWP对每一个执行流进行调度。

4.2线程等待

一个线程在创建后，需要像进程一样被等待回收线程的资源。如果主线程不对新线程进行等待，那么这个新线程的资源也是不会被回收的。会出现内存泄漏的问题。

函数原型：

int pthread_join(pthread_t thread, void **retval);

参数：

thread：需要等待的线程ID
retval：线程退出时的退出码信息

返回值：等待成功返回0，失败-1

注意：

如果thread线程通过return返回，那么retval指向的单元存放的是thread线程函数的返回值
如果thread线程被别的线程调用pthread_cancel异常终止掉，retval指向的单元存放的是宏PTHREAD_CANCELED，它的值本质上是-1
如果thread线程是自己调用pthread_exit终止，retval指向的单元是传给pthread_exit的参数
如果对thread线程的终止状态不感兴趣，可以传递nullptr给retval参数

void* routine(void* arg){
    char* msg=(char*)arg;
    int cnt=5;
    while(cnt--){
        std::cout<<"I am "<<msg<<"...pid:"<<getpid()<<"  ppid:"<<getppid()
        <<"  tid:"<<pthread_self()<<"  LWP:"<<::syscall(SYS_gettid)<<std::endl;
        sleep(1);
    }
    return (void*)10;
}
int main(){
    pthread_t tid[5];
    for(int i=0;i<5;i++){
        char* buf=(char*)malloc(64);
        sprintf(buf,"thread %d",i);
        pthread_create(&tid[i],nullptr,routine,buf);
    }
    for(int i=0;i<5;i++){
        void* ret=nullptr;
        pthread_join(tid[i],&ret);
        std::cout<<"thread "<<tid[i]<<" quit..."<<"exitcode: "<<(long)ret<<std::endl;	//需要使用long类型，在64位机器下指针类型为8字节
    }
    return 0;
}

需要注意的是，等待线程是一个阻塞的过程

为什么线程退出只能拿到退出码？

如果我们等待的是一个进程，那么当这个进程退出时，我们可以通过wait函数或是waitpid函数的输出型参数status，获取到退出进程的退出码、退出信号以及core dump标志。

为什么线程只能拿到退出码？

线程退出一共只有三种情况：

代码执行完毕，结果正确退出
代码执行完毕，结果不正确退出
代码异常终止

由于线程是进程的一个执行流，当进程中的一共线程出现异常退出时，那么整个进程也会因此而崩溃，此时我们根本没办法执行pthread_join函数，因为整个进程已经退出了。

比如下面一个线程发生除0错误

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <sys/syscall.h>


void* routine(void* arg){
    char* msg=(char*)arg;
    while(1){
        std::cout<<"I am "<<msg<<"...pid:"<<getpid()<<"  ppid:"<<getppid()
        <<"  tid:"<<pthread_self()<<"  LWP:"<<::syscall(SYS_gettid)<<std::endl;
        sleep(1);
    }
    return (void*)10;
}
void* err_routine(void* arg){
    char* msg=(char*)arg;
    int cnt=5;
    while (cnt--)
    {
        std::cout<<"I am "<<msg<<"...pid:"<<getpid()<<"  ppid:"<<getppid()
        <<"  tid:"<<pthread_self()<<"  LWP:"<<::syscall(SYS_gettid)<<std::endl;
        sleep(1);
    }
    int a=0;
    int num=10/a;
    while(1){

    }
}
int main(){
    pthread_t tid[5];
    pthread_t ttid;
    for(int i=0;i<5;i++){
        char* buf=(char*)malloc(64);
        sprintf(buf,"thread %d",i);
        pthread_create(&tid[i],nullptr,routine,buf);
    }
    pthread_create(&ttid,nullptr,err_routine,(void*)"thread_err");
    for(int i=0;i<5;i++){
        void* ret=nullptr;
        pthread_join(tid[i],&ret);
        std::cout<<"thread "<<tid[i]<<" quit..."<<"exitcode: "<<(long)ret<<std::endl;
    }
    pthread_join(ttid,nullptr);
    return 0;
}

pthread_join函数只能获取到线程正常退出时的退出码，用于判断线程的运行结果是否正确。

4.3进程终止

如果需要只终止某个线程而不终止整个进程,可以有三种方法:

从线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit。终止的线程不能调用exit，exit退出的是整个进程
线程可以调用pthread_ exit终止自己。
一个线程可以调用pthread_ cancel终止同一进程中的另一个线程。

pthread_exit函数

功能：线程终止
原型
void pthread_exit(void *value_ptr);
参数
value_ptr:value_ptr不要指向一个局部变量。
返回值：无返回值，跟进程一样，线程结束的时候无法返回到它的调用者（自身）

pthreaad_cancel函数

功能：取消一个执行中的线程
原型
int pthread_cancel(pthread_t thread);
参数
thread:线程ID
返回值：成功返回0；失败返回错误码

下面我们使用pthread_exit()退出线程，线程的退出码设置为555

void* routine(void* arg){
    char* msg=(char*)arg;
    int cnt=5;
    while(cnt--){
        std::cout<<"I am "<<msg<<"...pid:"<<getpid()<<"  ppid:"<<getppid()
        <<"  tid:"<<pthread_self()<<"  LWP:"<<::syscall(SYS_gettid)<<std::endl;
        sleep(1);
    }
    pthread_exit((void*)555);
}
int main(){
    pthread_t tid[5];
    for(int i=0;i<5;i++){
        char* buf=(char*)malloc(64);
        sprintf(buf,"thread %d",i);
        pthread_create(&tid[i],nullptr,routine,buf);
    }
    for(int i=0;i<5;i++){
        void* ret=nullptr;
        pthread_join(tid[i],&ret);
        std::cout<<"thread "<<tid[i]<<" quit..."<<"exitcode: "<<(long)ret<<std::endl;
    }
    return 0;
}

下面主线程调用pthread_canacel()取消创建的线程

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <sys/syscall.h>


void* routine(void* arg){
    char* msg=(char*)arg;
    while(1){
        std::cout<<"I am "<<msg<<"...pid:"<<getpid()<<"  ppid:"<<getppid()
        <<"  tid:"<<pthread_self()<<"  LWP:"<<::syscall(SYS_gettid)<<std::endl;
        sleep(1);
    }
    return (void*)555;
}
int main(){
    pthread_t tid[5];
    for(int i=0;i<5;i++){
        char* buf=(char*)malloc(64);
        sprintf(buf,"thread %d",i);
        pthread_create(&tid[i],nullptr,routine,buf);
    }
    int cnt=5;
    while(cnt--){
        sleep(1);
    }
    for(int i=0;i<5;i++){
        pthread_cancel(tid[i]);
    }
    for(int i=0;i<5;i++){
        void* ret=nullptr;
        pthread_join(tid[i],&ret);
        std::cout<<"thread "<<tid[i]<<" quit..."<<"exitcode: "<<(long)ret<<std::endl;
    }
    return 0;
}

也可以使用新创建的线程取消主线程，由于主线程的轻量级进程ID与进程ID相等，因此结果是整个进程被取消。

4.4线程分离

线程分离状态，指定该状态，线程主动与主控线程断开联系。线程结束后，其退出状态不由其他线程获取，而由自己主动释放，同时资源也被系统回收。常用于网络，多线程服务器。

默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。
一般情况下，线程终止后，其终止状态一直保留到其他线程调用pthread_join获取它的状态为止。但是线程可以被置为detach状态，这样线程一旦终止，内核就会立刻回收它的所有资源，而不是保留它的终止状态。
不能对一个detah状态的线程调用pthread_join，也不能对一个join状态的线程调用pthread_detach。

int pthread_detach(pthread_t thread);

**实例：**新线程从主线程分离，5秒后线程退出。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <sys/syscall.h>


void* routine(void* arg){
    char* msg=(char*)arg;
    int cnt=5;
    while(cnt--){
        std::cout<<"I am "<<msg<<"...pid:"<<getpid()<<"  ppid:"<<getppid()
        <<"  tid:"<<pthread_self()<<"  LWP:"<<::syscall(SYS_gettid)<<std::endl;
        sleep(1);
    }
    std::cout<<"thread "<<msg<<" quit..."<<std::endl;
    pthread_exit((void*)555);
}
int main(){
    pthread_t tid[5];
    for(int i=0;i<5;i++){
        char* buf=(char*)malloc(64);
        sprintf(buf,"thread %d",i);
        pthread_create(&tid[i],nullptr,routine,buf);
        pthread_detach(tid[i]);
    }
    while (1)
    {
        std::cout<<"I am main thread..."<<std::endl;
    }
    return 0;
}

5.线程ID与线程结构

pthread_create函数会产生一个线程ID，存放在第一个参数指向的地址中，该线程ID和内核中的LWP不是一回事。
内核中的LWP属于进程调度的范畴，因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。

下面我们用地址的方式打印线程ID

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <sys/syscall.h>


void* routine(void* arg){
    pthread_cancel(pthread_self());
    
}
int main(){
    pthread_t tid[5];
    for(int i=0;i<5;i++){
        pthread_create(&tid[i],nullptr,routine,nullptr);
    }
    for(int i=0;i<5;i++){
        printf("%p\n",tid[i]);
    }
    sleep(1);
    for(int i=0;i<5;i++){
        pthread_join(tid[i],nullptr);
    }
    return 0;
}

线程pthread_t本质上就是一个地址

线程运行时，需要调用函数，因此可能会创建临时变量
线程有属于自己的线程栈结构

线程的实现并不是全部由OS实现，**而是OS提供执行流，具体的线程结构是由链接的pthread库来提供管理；**同时pthread库可以提供多个线程，因此pthread需要对线程结构进行管理。

线程结构图

线程库pthread是一个动态库，在使用时被链接到进程的共享区中。

pthread_t保存了对应分配线程结构体struct thread_info的起始地址
主线程使用的是mm_struct中栈的内存
其他线程使用的是共享区中pthread库准备好的结构体

线程局部存储

进程中的所有线程共享全局变量

int global=100;
void* routine(void* arg){
    global=200;
    printf("global:%d\n",global);
    pthread_cancel(pthread_self());
}
int main(){
    pthread_t tid;
    pthread_create(&tid,nullptr,routine,nullptr);
    sleep(2);
    printf("global:%d\n",global);
    pthread_join(tid,nullptr);
    return 0;
}

使用__thread修饰变量，可以做到每个线程各拥有一份变量

__thread int global=100;
void* routine(void* arg){
    global=200;
    printf("global:%d\n",global);
    pthread_cancel(pthread_self());
}
int main(){
    pthread_t tid;
    pthread_create(&tid,nullptr,routine,nullptr);
    sleep(2);
    printf("global:%d\n",global);
    pthread_join(tid,nullptr);
    return 0;
}