【Linux】线程详解

1. 线程概念

1.1 什么是线程

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

进程的创建伴随着进程控制块，进程地址空间以及页表的创建，虚拟地址和物理地址就是通过页表建立映射的。
但是如果我们在创建“进程”时，只创建task_struct，并要求创建出来的task_struct和父task_struct共享进程地址空间和页表，那么创建的结果就是这样的。

此时我们创建的实际上就是四个线程：

• 其中每一个线程都是当前进程里面的一个执行流，也就是我们说的“线程是进程内部的一个执行分支”。
• 同时我们也可以看出，线程在进程内部运行，本质就是线程在进程地址空间内运行，也就是说曾经这个进程申请的所有资源，几乎都是被所有线程共享的。

注意：单纯从技术角度，这个是一定能实现的，因为它比创建一个原始进程所做的工作更加轻量化了。

该如何理解之前的进程？

所谓的进程并不是通过task_struct来衡量的，除了task_struct之外，一个进程还要有进程地址空间，文件，信号等等，合起来称为一个进程。
如果我们站在内核角度来看，承担分配系统资源的基本实体，叫做进程。
换言之，当我们创建进程时是创建一个task_struct，创建地址空间，维护页表，然后在物理内存当中开辟空间，构建映射，打开进程默认打开的相关文件，注册信号对应的处理方案等等。
而我们之前接触到的进程都只有一个task_struct，也就是该进程内部只有一个执行流，即单执行流进程，反之，内部有多个执行流的进程叫做多执行流进程。

在Linux中，站在CPU的角度，能否识别当前调度的task_struct是进程还是线程？

不能！也不需要，CPU只关心一个一个的独立执行流。无论进程内部只有一个执行流还是有多个执行流，CPU都是以task_struct为单位进行调度的。

单执行流进程被调度：

多执行流进程被调度：

Linux并不存在真正的线程，Linux中的线程是用进程模拟的！

操作系统中存在大量的进程，一个进程内又存在一个或多个线程，因此线程的数量一定比进程的数量多，当线程的数量足够多的时候，很明显线程的执行粒度要比进程更细。

如果一款操作系统要支持线程，那么就需要对这些线程进行管理，比如线程创建，线程调度，线程切换，线程资源分配，线程资源释放及回收等等，这些操作相比于进程都需要另起炉灶，搭建一套比进程平行的线程管理模块。

因此，如果要支持线程一定会提高操作系统设计的复杂程度。但是在Linux看来，描述进程的控制块和描述线程的控制块是很类似的，于是Linux就没有重新为线程设计管理模块，而是直接复用了进程控制块，所以我们可以说Linux中的线程也叫做轻量级进程。

也有真的为线程设计控制块的操作系统，比如Window操作系统，因此Windows操作系统的实现逻辑一定比Linux的实现逻辑要复杂的多。

既然在Linux中没有真正的线程，那么也就没有真正与线程相关的系统调用！

Linux中都没有真正意义上的线程了，自然也就没有真正意义上的与线程相关的系统调用了。但是Linux提供了创建轻量级进程的接口，也就是创建进程，共享空间，比如vfork函数。

vfork可以创建子进程，但是父子共享进程地址空间。
vfork的返回值与fork函数返回值相同，都是给父进程返回子进程PID，给子进程返回0。

vfork创建的子进程与父进程共享进程地址空间，下面用代码进行演示，父进程使用vfork函数创建子进程，子进程改变全局变量，父进程读取全局变量，看看读取的全局变量是否经过修改。

#include 
#include 
#include 
#include 

int g_val = 100;

int main()
{
    pid_t id = vfork();
    if (id == 0)
    {
        g_val = 200;
        exit(0);
    }
    sleep(3);
    printf("g_val: %d\n", g_val);
    return 0;
}

运行结果如下：

可以看到父进程读取的值是修改之后的值，这就说明了父进程和子进程此时是共享地址空间的。

线程库pthread

Linux中，在内核角度没有真正意义上与线程有关的接口，但是站在用户角度，系统为用户封装并提供了原生线程库pthread。

pthread库其实就是对轻量级进程的系统调用进行了封装，在用户层模拟实现了一套线程相关的接口。

因此对于我们来讲，我们要在Linux下学习线程实际上就是学习用户层的这一套接口，而非操作系统的接口。

1.2 线程的优点

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

1.3 线程的缺点

• 性能损失：一个很少被外部事件阻塞的计算密集型线程往往无法与其他线程共享一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。
• 健壮性降低：编写多线程需要更全面深入的考虑，在一个多线程程序里，因时间分配上的细微差别或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说，线程之间是缺乏保护的。
• 缺乏访问控制：进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。
• 编程难度提高：编写与调试一个多线程程序比单线程程度困难得多。

1.4 线程异常

• 单个线程如果出现除0，野指针等问题导致线程崩溃，进程也会随着崩溃。
• 线程是进程的执行分支，线程出现异常，就类似进程出现异常，会除法信号机制，终止进程，进程终止之后该进程内所有线程也会随即退出。

1.5 线程用途

• 合理地使用多线程，能提高CPU密集型程序的执行效率。
• 合理地使用多线程，能提高IO密集型程序的用户体验。

1.6 二级页表

以32位平台为例，在32位平台下一共有2³²个地址，也就意味着需要有2³²个地址需要被映射。

如果我们所谓的页表就是单纯的一张表，那么这张表就需要建议2³²个虚拟地址与物理地址之间的映射关系，即这张表要有2³²个映射项。
且每一个表项中除了要有虚拟地址与其映射的物理地址之外，实际上还需要有一些权限信息，比如我们所说的用户级页表和内核级页表，实际就是通过权限进行区分的。

每个页表中存储一个物理地址和一个虚拟地址就需要8个字节，考虑到还需要包含权限相关的各种信息，这里每一个表项就按10个字节计算。
这里一共有2³²个表项，也就意味着存储这张页表我们需要用2³² * 10个字节，也就是40GB。而在32位平台下我们的内存可能一共就只有4GB，也就是说我们根本无法存储这样一张页表。

因此所谓的页表就不是单纯的一张表

还是以32位平台为例，其页表的映射如下：

1. 选择虚拟地址的前10个比特位在页目录下进行查找，找到对应的页表
2. 再选择虚拟地址的10个比特位在对应的页表当中进行查找，找到物理内存中对应页框的起始地址
3. 最后将虚拟地址中剩下的12个比特位作为偏移量从对应页框的起始地址处向后偏移，找到物理内存中某一个对应的字节数据

相关说明：

1. 物理内存实际是被划分成一个个4KB大小的页框的，而磁盘上的程序也是被划分成一个个4KB大小的页帧的，当内存和磁盘进行数据交换时就是以4KB为单位进行加载和保存的。
2. 4KB实际上就是2¹²个字节，也就是说一个页框中有2¹²个字节，而访问内存的基本大小是1字节，因此一个页框中就有2¹²个地址，于是我们就可以将剩下的12个比特位作为偏移量，从页框的起始地址处开始向后进行便宜，从而找到物理内存中某一个对应字节数据。

这实际上就是我们所谓的二级页表，其中页目录项是一级页表，页表项是二级页表。

每一个表项还是按10字节计算，页目录和页表的表项都是2¹⁰个，因此一个表的大小就是2¹⁰ * 10个字节，也就是10KB。而页目录有2¹⁰个表项也就意味着页表有2¹⁰个，也就是说一级页表有1张，二级页表有2¹⁰张，总共算下来就是10MB，内存消耗并不高，Linux实际上就是这样映射的。

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

注意：在Linux中，32位平台下用的是二级页表，64位平台下采用的是多级页表。

修改常量字符串为什么会触发段错误？

当我们要修改一个字符串常量时，虚拟地址必须经过页表映射找到对应的物理内存，而在查表过程中发现其权限是只读的，此时你要对其进行修改就会在MMU内部触发硬件错误，操作系统在识别到是哪一个进程导致的之后，就会给该进程发送的信号对其进行终止。

1.7 线程与进程对比

进程是承担分配系统资源的基本实体，线程是调度的基本单位。

线程共享进程数据，但也拥有自己的一部分数据：

• 线程ID
• 一组寄存器
• 栈空间
• errno变量
• 信号屏蔽字
• 调度优先级

同一进程的线程共享一些资源：

因为是在同一个地址空间，因此所谓的代码段（Text Segment），数据段（Data Segment）都是共享的：

• 如果定义一个函数，在各线程中都可以使用
• 如果定义一个全局变量，在各线程中都可以访问到

除此之外，各线程还共享以下进程资源和环境：

• 文件描述符表（进程打开一个文件后，其他进程也能看到）
• 每种信号的处理方式（SIG_IGN，SIG_DFL或者自定义的信号处理函数）
• 当前工作目录
• 用户ID

2. 线程控制

2.1 POSIX线程库

在上面提到，Linux在内核层面没有专门为线程设计一套系统调用接口，但是在应用层为用户提供了一套原生线程库。

pthread线程库就是应用层的原生线程库：

• 应用层指的是这个线程库并不是系统接口直接提供的，而是由第三方帮我们提供的
• 原生指的是大部分Linux系统都会默认带上该线程库
• 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以"pthread_"打头的
• 要使用这些函数库，需要包含头文件pthread.h
• 链接这些线程函数库时，要使用编译器的"-lpthread"选项

错误检查：

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

2.2 线程创建

创建线程的函数为pthread_create

参数说明：

• thread：获取创建成功的线程ID，该参数是一个输出型参数
• attr：用户设置线程的属性，传入NULL表示默认属性
• start_routine：该参数是一个函数地址，表示线程例程，即线程启动后要执行的函数
• arg：传给线程例程的参数

返回值说明：

• 线程创建成功返回0，失败返回错误码。

让主线程创建一个新线程

当一个程序启动时，就有一个进程被操作系统创建，此时一个线程也立刻运行，这个线程就叫做主线程。

• 主线程是产生其他子线程的线程
• 通常主线程必须最后完成某些执行动作，比如各种关闭动作

下面我们让主线程调用pthread_create函数创建一个新线程，此后新线程就会跑去执行自己的新例程，而主线程则继续执行后续代码。

#include 
#include 
#include 

void* Routine(void* arg)
{
    const char* msg = (char*)arg;
    while (1)
    {
        printf("I am %s\n", msg);
        sleep(1);
    }
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, NULL, Routine, (void*)"thread 1");
    while (1)
    {
        printf("I am main thread!\n");
        sleep(2);
    }
    return 0;
}

运行结果如下：

使用ps -aL命令，可以显示当前的轻量级进程。

• 不带-L，看到是就一个个的进程
• 带-L，看到的是每个进程内的多个轻量级进程

其中，LWP（light weight process）就是轻量级进程的ID，可以看到显示的两个轻量级进程的PID是相同的，因为它们属于同一个进程。

注意：在Linux中，应用层的线程与内核的LWP是一一对应的，实际上操作系统调度的时候采用的是LWP，而并非PID，只不过我们之前接触到的都是单线程进程，其PID和LWP是相等的，所以对于单线程进程来说，调度时采用PID和LWP是一样的。

让主线程创建一批新线程

上面是主线程创建一个新线程，下面我们让主线程一次性创建五个新线程，并让创建的每一个新线程都去执行Routine函数，也就是说Routine函数会被重复进入，即该函数是可重入的。

#include 
#include 
#include 
#include 
#include 

void* Routine(void* arg)
{
    char* msg = (char*)arg;
    while (1)
    {
        printf("I am %s\n", msg);
        sleep(1);
    }
}

int main()
{
    pthread_t tid[5];
    for (int i = 0; i < 5; ++i)
    {
        char* buffer = (char*)malloc(64);
        sprintf(buffer, "thread %d", i);
        pthread_create(&tid[i], NULL, Routine, buffer);
    }
    while (1)
    {
        printf("I am main pthread\n");
        sleep(2);
    }
    return 0;
}

运行结果如下：

此时再用ps -aL命令查看，就会发现六个轻量级进程。

获取线程ID

常见获取线程ID的方式有两种：

• 创建线程时通过输出型参数获得
• 通过调用pthread_self函数获得

pthread_self的函数原型如下：

调用pthread_self函数获得当前线程的ID，与调用getpid函数获取当前进程的ID使用方法一样，这里也就不演示了。

2.3 线程等待

线程和进程一样，也是需要被等待的。如果主线程不断对新线程进程等待，那么这个新线程的资源也是不会被回收的。所以线程需要被等待，如果不等待产生类似于“僵尸进程”的问题，也就是内存泄漏。
我们使用pthread_join函数进行线程等待。

参数说明：

• thread：被等待线程的ID
• retval：线程退出时的退出码信息

返回值说明：

• 线程等待成功返回0，失败返回退出码。

调用该函数的线程将挂起等待，知道ID为thread的线程终止，thread线程将以不同的方法终止，通过pthread_join得到的终止状态是这样的：

• 如果thread线程通过return返回，retval所指向的单元里存放的是thread线程的返回值
• 如果thread线程被别的线程pthread_cancel异常终止掉，retval所指向的单元里存放的是常数PTHREAD_CANCELED
• 如果thread线程是自己调用pthread_exit终止的，retval所指向的单元里存放的是传给pthread_exit的参数
• 如果不打算知道thread线程的终止状态，可以传NULL给retval参数

例如，如果我们不关心线程的退出信息，代码可以这样写

#include 
#include 
#include 
#include 
#include 

void* Routine(void* arg)
{
    char* msg = (char*)arg;
    int cnt = 3;
    while (1)
    {
        printf("I am %s\n", msg);
        sleep(1);
        if (cnt-- == 0) break;
    }
    return NULL;
}

int main()
{
    pthread_t tid[5];
    for (int i = 0; i < 5; ++i)
    {
        char* buffer = (char*)malloc(64);
        sprintf(buffer, "thread %d", i);
        pthread_create(&tid[i], NULL, Routine, buffer);
    }

    printf("I am main pthread\n");

    for (int i = 0; i < 5; ++i)
    {
        pthread_join(tid[i], NULL);
        printf("thread %d quit!\n", i);
    }

    return 0;
}

如果我们关心进程的退出信息，那么代码可以这样写。

#include 
#include 
#include 
#include 
#include 

void* Routine(void* arg)
{
    char* msg = (char*)arg;
    int cnt = 3;
    while (1)
    {
        printf("I am %s\n", msg);
        sleep(1);
        if (cnt-- == 0) break;
    }
    return (void*)2023;
}

int main()
{
    pthread_t tid[5];
    for (int i = 0; i < 5; ++i)
    {
        char* buffer = (char*)malloc(64);
        sprintf(buffer, "thread %d", i);
        pthread_create(&tid[i], NULL, Routine, buffer);
    }

    printf("I am main pthread\n");

    void* ret = NULL;
    for (int i = 0; i < 5; ++i)
    {
        pthread_join(tid[i], &ret);
        printf("thread %d quit, exitCode: %d\n", i, (int)ret);
    }

    return 0;
}

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

如果我们等待的是一个进程，那么当这个进程退出时，我们可以通过status变量拿到进程的退出码、退出信号和code dump标准。

那为什么等待线程的时候我们只能拿到线程的退出码？线程是进程内部的执行分支，如果进程中某个线程崩溃了，那么整个进程也会崩溃，此时我们根本没办法执行pthread_join函数，因为整个进程已经退出了。
所以pthread_join函数只能获取线程正常退出时的退出码，用于判断线程的运行结果是否正确。

2.4 线程终止

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

1. 从线程函数return
2. 线程可以自己调用pthread_exit函数终止自己
3. 一个线程可以调用pthread_cancel函数终止同一进程的另一个线程

return退出

在线程中使用return代表当前线程退出，但是在main函数中使用return代表整个进程退出，也就是说只要主线程退出了那么整个进程就退出了，此时该进程曾经申请的资源就会被释放，而其他线程会因为没有了资源，自然而然地也就退出了。

pthread_exit函数

参数为线程退出时的退出码信息。
pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者静态分配的，不能在线程函数的栈上分配，因为当其他线程得到这个返回指针时，线程函数已经退出了。

pthread_cancel函数

线程是可以被取消的，我们可以使用pthread_cancel函数取消某一个线程。

参数为要被取消线程的ID。如果线程取消成功返回0，失败返回错误码。
线程是可以取消自己的，取消成功的退出码一般是-1。

此外，新线程也是可以取消主线程的。

• 当新线程取消主线程时，主线程和各个新线程之间的地位是对等的，取消一个线程，其他先也是能够跑完的，只不过主线程不再执行后续代码了。
• 我们一般用主线程去控制新线程，这才符合我们对线程控制的基本逻辑，虽然新线程可以取消主线程，但是不推荐这样做。

2.5 分离线程

• 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成内存泄漏。
• 但如果我们不关心线程的返回值，join也是一种负担，此时我们可以将该线程进行分离，后续当线程退出时就会自动释放线程资源。
• 一个线程如果被分离了，这个线程依旧要使用该进程的资源，依旧在该进程中运行，甚至这个线程崩溃了一定会影响其他线程，只不过这个线程退出时不再需要主线程去join了，当这个线程退出时系统会自动回收该线程所对应的资源。
• 可以是线程组内其他进程对目标线程进行分离，也可以是线程自己分离。
• joinable和分离是冲突的，一个线程不能既是joinable又是分离的。

分离线程的函数叫做pthread_detach

参数为被分离的线程ID，当分离成功返回0，分离失败返回错误码。

2.6 线程ID及进程地址空间

• pthread_create函数会产生一个线程ID，存在第一个参数指向的地址中，该线程ID和内核中的LWP不是一回事。
• 内核中的LWP属于进程调度的范畴，因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。
• pthread_create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，线程的后续操作就是操作该线程ID来操作线程的。
• 线程库提供的pthread_self函数，获取的线程ID和pthread_create函数第一个参数获取的线程ID是一样的。

pthread_t到底是什么类型呢？

首先，Linux不提供真正的线程，只提供LWP，也就意味着操作系统只需要对内核执行流LWP进行管理，而供用户使用的线程接口等其他数据，应该由线程库自己来管理，因此管理管理时的“先描述，再组织”就应该在线程库里运行。

通过ldd命令可以看到，我们采用的线程库实际上是一个动态库。

进程运行时动态库被加载到内存，然后通过页表映射到进程地址空间的共享区，此时该进程内的所有线程都是能看到这个动态库的。

我们说的每个线程都有自己私有的栈，其中主线程采用的栈是进程地址空间中原生的栈，而其余线程采用的栈就是在共享区中开辟的。除此之外，每个线程都有自己的struct pthread，当中包含了对应线程的各种属性。每个线程都有自己的线程局部存储，当中包含了对应线程被切换时的上下文数据。
每一个新线程在共享区都有这样一块区域对其进行描述，因此我们要找到一个用户级线程只需要找到该线程内存块的起始地址，然后就可以获取该线程的各种信息。

上面我们所用的各种线程函数，本质就是在库内部对线程属性进行的各种操作，操作将要执行的代码交给对应的内核级LWP去执行就行了，也就是说线程数据的管理本质是在共享区的。

pthread_t到底是什么类型取决于实现，但是对于Linux目前实现的线程库来说，线程ID本质就是进程地址空间共享区上的一个虚拟地址，同一个进程中的所有虚拟地址都是不同的，因此可以用它来唯一区分每一个线程。

pthread_t到底是什么类型取决于实现，但是对于Linux目前实现的线程库来说，线程ID本质就是进程地址空间共享区进程地址空间共享区上的一个虚拟地址，同一个进程中所有的虚拟地址都是不同的，因此可以同它来唯一区分每一进程。

我们可以尝试按地址的形式对获取到的线程ID进行打印。

#include 
#include 
#include 

void* Routine(void* arg)
{
	while (1){
		printf("new  thread tid: %p\n", pthread_self());
		sleep(1);
	}
}
int main()
{
	pthread_t tid;
	pthread_create(&tid, NULL, Routine, NULL);
	while (1){
		printf("main thread tid: %p\n", pthread_self());
		sleep(2);
	}
	return 0;
}

可以看到，打印的就是地址，所以tid的本质也就是一个地址。