Linux 线程深度解析：从内存管理到线程控制的核心机制

引言

在现代操作系统中，多线程编程是提升程序并发能力的关键技术。Linux 通过轻量级进程（LWP）实现线程机制，将进程资源与执行流分离，使得多个线程可共享同一地址空间并独立调度。本文从底层内存管理出发，深入剖析分页式存储、页表结构与struct page的设计原理，进而探讨线程与进程的本质区别。同时，结合 POSIX 线程库的核心函数（如pthread_create、pthread_join等），解析线程创建、终止、等待及资源管理的全流程，帮助开发者理解 Linux 线程的实现逻辑与编程实践要点。

一、Linux 线程概念

1.1 什么是线程

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

1.2 分页式存储管理

1.2.1 虚拟地址和页表的由来

思考一下，如果在没有虚拟内存和分页机制的情况下，每一个用户程序在物理内存上所对应的空间必须是连续的，如下图：

因为每一个程序的代码、数据长度都是不一样的，按照这样的映射方式，物理内存将会被分割成各种离散的、大小不同的块。经过一段运行时间之后，有些程序会退出，那么它们占据的物理内存空间可以被回收，导致这些物理内存都是以很多碎片的形式存在。

怎么办呢？我们希望操作系统提供给用户的空间必须是连续的，但是物理内存最好不要连续。此时虚拟内存和分页便出现了，如下图所示：

把物理内存按照一个固定的长度的页框进行分割，有时叫做物理页。每个页框包含一个物理页(page)。一个页的大小等于页框的大小。大多数32位体系结构支持4KB的页，而64位体系结构一般会支持8KB的页。区分一页和一个页框是很重要的：

• 页框是一个存储区域；
• 而页是一个数据块，可以存放在任何页框或磁盘中。

有了这种机制，CPU便并非是直接访问物理内存地址，而是通过虚拟地址空间来间接的访问物理内存地址。所谓的虚拟地址空间，是操作系统为每一个正在执行的进程分配的一个逻辑地址，在32位机上，其范围从0～4G-1。

操作系统通过将虚拟地址空间和物理内存地址之间建立映射关系，也就是页表，这张表上记录了每一对页和页框的映射关系，能让CPU间接的访问物理内存地址。

总结一下，其思想是将虚拟内存下的逻辑地址空间分为若干页，将物理内存空间分为若干页框，通过页表便能把连续的虚拟内存，映射到若干个不连续的物理内存页。这样就解决了使用连续的物理内存造成的碎片问题。

1.2.2 物理内存管理

假设一个可用的物理内存有4GB的空间。按照一个页框的大小4KB进行划分，4GB的空间就是4GB/4KB=1048576个页框。有这么多的物理页，操作系统肯定是要将其管理起来的，操作系统需要知道哪些页正在被使用，哪些页空闲等等。

内核用struct page结构表示系统中的每个物理页，出于节省内存的考虑，struct page中使用了大量的联合体union。

struct page {unsigned long flags;        // 页状态标志位（如PG_locked、PG_uptodate等）atomic_t _count;            // 引用计数：表示有多少地方正在使用该页union {struct {                // 用于页缓存（Page Cache）struct list_head lru;  // 链表节点，用于LRU队列struct address_space *mapping;  // 映射的地址空间pgoff_t index;       // 在映射中的偏移量};struct {                // 用于匿名页（未映射到文件）struct mm_struct *mapping;  // 指向所属的内存描述符void *virtual;      // 虚拟地址（如果已映射）};};struct page *next_hash;     // 哈希表指针，用于页缓存哈希...
};

关键字段解析

• flags：
  • 包含多个状态位，如：
    • PG_locked：页被锁定，不可交换或修改。
    • PG_uptodate：页数据已更新，无需从磁盘读取。
    • PG_dirty：页数据已修改，需写回磁盘。
• _count：
  • 引用计数为 0 时，表示页未被使用，可被回收。
• mapping：
  • 对于文件映射页，指向文件的地址空间（address_space）。
  • 对于匿名页（如堆、栈），指向进程的内存描述符（mm_struct）。

struct page 的主要用途

1. 内存管理
   • 页分配与回收：内核通过 struct page 跟踪空闲页框，使用伙伴系统（Buddy System）分配和回收物理页。
   • 页置换：当内存不足时，内核根据 struct page 的状态（如是否脏页、最近使用情况）选择置换页。
2. 页缓存（Page Cache）
   • 用于缓存磁盘文件数据，加速文件读写。
   • struct page 通过 mapping 和 index 字段关联文件偏移，实现文件内容与物理页的映射。
3. 虚拟内存管理
   • 匿名页（如进程堆、栈）通过 struct page 与进程的虚拟地址空间关联。
   • 当发生缺页异常时，内核通过 struct page 分配物理页并建立映射。
4. 内存碎片整理
   • 内核通过 struct page 检测和整理内存碎片，提高连续内存分配成功率。

1.2.3 页表

页表中的每一个表项，指向一个物理页的开始地址。在32位系统中，虚拟内存的最大空间是4GB，这是每一个用户程序都拥有的虚拟内存空间。既然需要让4GB的虚拟内存全部可用，那么页表中就需要能够表示这所有的4GB空间，那么就一共需要4GB/4KB=1048576个表项。如下图所示：

虚拟内存看上去被虚线“分割”成一个个单元，其实并不是真的分割，虚拟内存仍然是连续的。这个虚线的单元仅仅表示它与页表中每一个表项的映射关系，并最终映射到相同大小的一个物理内存页上。

页表中的物理地址，与物理内存之间，是随机的映射关系，哪里可用就指向哪里（物理页)。虽然最终使用的物理内存是离散的，但是与虚拟内存对应的线性地址是连续的。处理器在访问数据、获取指令时，使用的都是线性地址，只要它是连续的就可以了，最终都能够通过页表找到实际的物理地址。

在32位系统中，地址的长度是4个字节，那么页表中的每一个表项就是占用4个字节。所以页表占据的总空间大小就是：1048576*4=4MB的大小。也就是说映射表自己本身，就要占用4MB/4KB=1024个物理页。这会存在哪些问题呢?

• 回想一下，当初为什么使用页表，就是要将进程划分为一个个页可以不用连续的存放在物理内存中，但是此时页表就需要1024个连续的页框，似乎和当时的目标有点背道而驰了…
• 此外，根据局部性原理可知，很多时候进程在一段时间内只需要访问某几个页就可以正常运行了。因此也没有必要一次让所有的物理页都常驻内存。

解决需要大容量页表的最好方法是：把页表看成普通的文件，对它进行离散分配，即对页表再分页，由此形成多级页表的思想。

为了解决这个问题，可以把这个单一页表拆分成1024个体积更小的映射表。如下图所示。这样一来，1024(每个表中的表项个数)*1024(表的个数)，仍然可以覆盖4GB的物理内存空间。

这里的每一个表，就是真正的页表，所以一共有1024个页表。一个页表自身占用4KB，那么1024个页表一共就占用了4MB的物理内存空间，和之前没差别啊?

从总数上看是这样，但是一个应用程序是不可能完全使用全部的4GB空间的，也许只要几十个页表就可以了。例如：一个用户程序的代码段、数据段、栈段，一共就需要10MB的空间，那么使用3个页表就足够了。

计算过程：

• 每一个页表项指向一个4KB的物理页，那么一个页表中1024个页表项，一共能覆盖4MB的物理内存;
• 那么10MB的程序，向上对齐取整之后(4MB的倍数，就是12MB)，就需要3个页表就可以了。

1.2.4 页目录结构

到目前为止，每一个页框都被一个页表中的一个表项来指向了，那么这1024个页表也需要被管理起来。管理页表的表称之为页目录表，形成二级页表。如下图所示：

• 所有页表的物理地址被页目录表项指向
• 页目录的物理地址被CR3寄存器指向，这个寄存器中，保存了当前正在执行任务的页目录地址。

所以操作系统在加载用户程序的时候，不仅仅需要为程序内容来分配物理内存，还需要为用来保存程序的页目录和页表分配物理内存。

1.2.5 两级页表的地址转换

下面以一个逻辑地址为例。将逻辑地址（0000000000，0000000001，·11111111111）转换为物理地址的过程：

1. 在32位处理器中，采用4KB的页大小，则虚拟地址中低12位为页偏移，剩下高20位给页表，分成两级，每个级别占10个bit（10+10)。
2. CR3 寄存器读取页目录起始地址，再根据一级页号查页目录表，找到下一级页表在物理内存中存放位置。
3. 根据二级页号查表，找到最终想要访问的内存块号。
4. 结合页内偏移量得到物理地址。
   
5. 注：一个物理页的地址一定是4KB对齐的(最后的12位全部为0），所以其实只需要记录物理页地址的高 20 位即可。
6. 以上其实就是MMU的工作流程。MMU(MemoryManage Unit)是一种硬件电路，其速度很快，主要工作是进行内存管理，地址转换只是它承接的业务之一。

到这里其实还有个问题，MMU要先进行两次页表查询确定物理地址，在确认了权限等问题后，MMU再将这个物理地址发送到总线，内存收到之后开始读取对应地址的数据并返回。那么当页表变为N级时，就变成了N次检索+1次读写。可见，页表级数越多查询的步骤越多，对于CPU来说等待时间越长，效率越低。

让我们现在总结一下：单级页表对连续内存要求高，于是引入了多级页表，但是多级页表也是一把双刃剑，在减少连续存储要求且减少存储空间的同时降低了查询效率。

有没有提升效率的办法呢？计算机科学中的所有问题，都可以通过添加一个中间层来解决。MMU引入了新武器，江湖人称快表的TLB（其实，就是缓存)

当CPU给MMU传新虚拟地址之后，MMU先去问TLB那边有没有，如果有就直接拿到物理地址发到总线给内存，齐活。但TLB容量比较小，难免发生Cache Miss，这时候MMU还有保底的老武器页表，在页表中找到之后MMU除了把地址发到总线传给内存，还把这条映射关系给到TLB，让它记录一下刷新缓存。

1.2.6 缺页异常

设想，CPU给MMU的虚拟地址，在TLB和页表都没有找到对应的物理页，该怎么办呢？其实这就是缺页异常Page Fault，它是一个由硬件中断触发的可以由软件逻辑纠正的错误。

假如目标内存页在物理内存中没有对应的物理页或者存在但无对应权限，CPU就无法获取数据，这种情况下CPU就会报告一个缺页错误。

由于CPU没有数据就无法进行计算，CPU罢工了用户进程也就出现了缺页中断，进程会从用户态切换到内核态，并将缺页中断交给内核的Page Fault Handler处理。

缺页中断会交给 Page Fault Handler 处理，其根据缺页中断的不同类型会进行不同的处理：

• Hard Page Fault也被称为Major Page Fault，翻译为硬缺页错误/主要缺页错误，这时物理内存中没有对应的物理页，需要CPU打开磁盘设备读取到物理内存中，再让MMU建立虚拟地址和物理地址的映射。
• SoftPage Fault也被称为Minor PageFault，翻译为软缺页错误/次要缺页错误，这时物理内存中是存在对应物理页的，只不过可能是其他进程调入的，发出缺页异常的进程不知道而已，此时MMU只需要建立映射即可，无需从磁盘读取写入内存，一般出现在多进程共享内存区域。
• Invalid Page Fault翻译为无效缺页错误，比如进程访问的内存地址越界访问，又比如对空指针解引l用内核就会报segment fault错误中断进程直接挂掉。

1.3 线程的优点

• 创建一个新线程的代价要比创建一个新进程小得多
• 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多
  • 最主要的区别是线程的切换虚拟内存空间依然是相同的，但是进程切换是不同的。这两种上下文切换的处理都是通过操作系统内核来完成的。内核的这种切换过程伴随的最显著的性能损耗是将寄存器中的内容切换出。
  • 另外一个隐藏的损耗是上下文的切换会扰乱处理器的缓存机制。简单的说，一旦去切换上下文，处理器中所有已经缓存的内存地址一瞬间都作废了。还有十个显著的区别是当你改变虚拟内存空间的时候，处理的页表缓冲TLB（快表）会被全部刷新，这将导致内存的访问在一段时间内相当的低效。但是在线程的切换中，不会出现这个问题，当然还有硬件cache。
• 线程占用的资源要比进程少很
• 能充分利用多处理器的可并行数量
• 在等待慢速I/O操作结束的同时，程序可执行其他的计算任务
• 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
• I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。

1.4 线程缺点

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

1.5 线程异常

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

1.6 线程用途

• 合理的使用多线程，能提高CPU密集型程序的执行效率
• 合理的使用多线程，能提高IO密集型程序的用户体验（如生活中我们一边写代码一边下载开发工具，就是多线程运行的一种表现）

二、Linux进程VS线程

2.1 进程和线程

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

2.2 进程的多个线程共享

同一地址空间，因此Text Segment、Data Segment都是共享的，如果定义一个函数,在各线程中都可以调用，如果定义一个全局变量，在各线程中都可以访问到，除此之外，各线程还共享以下进程资源和环境：

• 文件描述符表
• 每种信号的处理方式(SIG_IGN、SIG_DFL或者自定义的信号处理函数)
• 当前工作目录
• 用户id和组id

进程和线程的关系如下图：

2.3 关于进程线程的问题

• 如何看待之前学习的单进程？具有一个线程执行流的进程

三、Linux线程控制

3.1 POSIX线程库

• 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的
• 要使用这些函数库，要通过引l入头文<pthread.h>
• 链接这些线程函数库时要使用编译器命令的 -lpthread 选项

3.2 创建线程

#include <pthread.h>int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);

• 参数说明：

  • thread：输出参数，指向 pthread_t 类型的变量，用于存储新创建线程的标识符。
  • attr：线程属性设置，通常传入 NULL 使用默认属性。
  • start_routine：线程入口函数，类型为 void* (*)(void*)，即返回值和参数均为 void* 的函数。
  • arg：传递给线程入口函数的参数（需强制转换为 void*）。

• 返回值：

  • 成功时返回 0，失败时返回错误码（如 EAGAIN、EINVAL 等），不设置 errno。

• 错误处理
  pthread_create() 失败时返回错误码，常见错误：

  • EAGAIN：系统资源不足，无法创建新线程。
  • EINVAL：attr 参数无效（如栈大小设置不合理）。
  • EPERM：没有权限设置指定的 attr。

3.2.1 基本用法示例

以下代码展示如何创建一个打印信息的线程：

#include <stdio.h>
#include <pthread.h>// 线程入口函数
void* print_message(void* arg) {char* message = (char*)arg;  // 转换参数类型printf("线程输出: %s\n", message);return NULL;  // 线程正常结束
}int main() {pthread_t thread_id;char* message = "Hello from pthread!";// 创建线程if (pthread_create(&thread_id, NULL, print_message, (void*)message) != 0) {perror("pthread_create failed");return 1;}// 等待线程结束（可选）if (pthread_join(thread_id, NULL) != 0) {perror("pthread_join failed");return 1;}printf("主线程继续执行\n");return 0;
}

3.2.2 线程属性（pthread_attr_t）

通过 pthread_attr_init() 和 pthread_attr_set*() 函数设置，常用属性包括：

• 分离状态（Detach State）：
  • PTHREAD_CREATE_JOINABLE（默认）：主线程需通过 pthread_join() 等待线程结束。
  • PTHREAD_CREATE_DETACHED：线程结束后自动释放资源，无法被 join。

  pthread_attr_t attr;
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  

• 栈大小（Stack Size）：

  size_t stack_size = 1024 * 1024;  // 1MB
  pthread_attr_setstacksize(&attr, stack_size);
  

3.3 线程终止

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

1. 从线程函数return。这种方法对主线程不适用，从main函数return相当于调用exit。
2. 线程可以调用pthread_exit终止自己。
3. 一个线程可以调用pthread_cancel终止同一进程中的另一个线程。

3.3.1 函数原型与参数

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

• 参数说明：
  • retval：线程的返回值，类型为 void*，可被等待该线程的其他线程通过pthread_join() 获取。若无需返回值，可传入 NULL。
• 返回值：
  无返回值（void），调用后当前线程立即终止。

3.3.2 基本用法示例

以下代码展示线程主动退出并传递返回值：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>// 线程入口函数
void* thread_function(void* arg) {int* data = (int*)arg;printf("线程收到参数: %d\n", *data);// 动态分配内存用于返回值int* result = malloc(sizeof(int));*result = (*data) * 2;// 线程主动退出并传递返回值pthread_exit((void*)result);
}int main() {pthread_t thread_id;int input = 42;void* retval;// 创建线程if (pthread_create(&thread_id, NULL, thread_function, &input) != 0) {perror("pthread_create failed");return 1;}// 等待线程结束并获取返回值if (pthread_join(thread_id, &retval) != 0) {perror("pthread_join failed");return 1;}printf("线程返回值: %d\n", *(int*)retval);free(retval);  // 释放动态分配的内存return 0;
}

3.3.3 核心作用与使用场景

1. 线程主动退出：
   • 当线程完成任务后，可调用 pthread_exit() 立即终止自身。
2. 传递返回值：
   • 通过 retval 参数向等待的线程传递结果（如计算结果、状态码）。
3. 资源清理：
   • 在退出前释放线程持有的资源（如锁、文件描述符），但需注意：
     • 线程局部存储（Thread-Local Storage, TLS）会自动释放。
     • 若线程是分离状态（PTHREAD_CREATE_DETACHED），retval 会被忽略。

3.3.4 pthread_exit() 与 return 的区别

对比项	pthread_exit()	return
作用范围	仅终止当前线程	终止整个函数，若为主线程则进程退出
返回值传递	通过 retval 传递给 pthread_join()	返回值类型需与线程函数声明一致
执行上下文	可在线程函数的任何位置调用	只能从线程函数的顶层返回
对主线程的影响	主线程退出，但进程不终止，其他线程继续运行	主线程返回会导致进程终止，所有线程退出

示例对比：

// 使用 pthread_exit()
void* thread_func(void* arg) {// ... 执行任务 ...pthread_exit(NULL);  // 仅当前线程退出
}// 使用 return
void* thread_func(void* arg) {// ... 执行任务 ...return NULL;  // 效果同上，但主线程使用 return 会终止进程
}

3.4 线程等待

为什么需要线程等待?

• 已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
• 创建新的线程不会复用刚才退出线程的地址空间。

3.4.1 函数原型与参数

#include <pthread.h>int pthread_join(pthread_t thread, void **retval);

• 参数说明：
  • thread：目标线程的标识符（由 pthread_create() 返回）。
  • retval：输出参数，指向 void* 的指针，用于存储目标线程的返回值（即 pthread_exit() 或 return 的参数）。若无需获取返回值，可传入 NULL。
• 返回值：
  • 成功时返回 0，失败时返回错误码（如 EDEADLK、ESRCH 等）。

3.4.2 基本用法示例

以下代码展示如何等待线程结束并获取返回值：

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>// 线程入口函数
void* calculate_sum(void* arg) {int* numbers = (int*)arg;int sum = numbers[0] + numbers[1];// 动态分配内存存储结果int* result = malloc(sizeof(int));*result = sum;pthread_exit((void*)result);  // 等价于 return (void*)result;
}int main() {pthread_t thread_id;int numbers[2] = {3, 5};void* retval;// 创建线程if (pthread_create(&thread_id, NULL, calculate_sum, numbers) != 0) {perror("pthread_create failed");return 1;}// 等待线程结束并获取返回值if (pthread_join(thread_id, &retval) != 0) {perror("pthread_join failed");return 1;}printf("计算结果: %d\n", *(int*)retval);free(retval);  // 释放动态分配的内存return 0;
}

3.4.3 核心作用与使用场景

1. 同步线程执行顺序：
   • 主线程通过 pthread_join() 等待工作线程完成任务，确保数据处理的顺序性。
2. 获取线程返回值：
   • 通过 retval 参数接收目标线程的返回值（如计算结果、状态码）。
3. 资源回收：
   • 回收线程的栈空间、线程描述符等资源，避免成为僵尸线程。

3.4.4 资源回收机制

• 僵尸线程（Zombie Thread）：
  • 线程结束后（通过 pthread_exit() 或 return），若未被 join，其资源不会被释放，成为僵尸线程。
  • 僵尸线程会占用系统资源（如线程 ID、内存），长期运行可能导致系统资源耗尽。
• pthread_join() 的作用：
  1. 阻塞调用线程，直到目标线程结束。
  2. 回收目标线程的资源。
  3. 通过 retval 获取目标线程的返回值。

3.4.5 错误处理与常见错误码

• EDEADLK：检测到死锁（如线程尝试等待自身）。
• ESRCH：指定的线程 ID 不存在或已被 join。
• EINVAL：线程已被设置为分离状态（PTHREAD_CREATE_DETACHED）。

推荐处理方式：

int ret = pthread_join(thread_id, &retval);
if (ret != 0) {fprintf(stderr, "pthread_join failed, error: %d\n", ret);// 进一步处理...
}

3.4.6 注意事项

1. 避免重复 join：
   对同一线程多次调用 pthread_join() 会导致未定义行为（通常返回 ESRCH）。
2. 内存管理：
   • 若线程返回值指向动态分配的内存（如 malloc），接收方需负责释放，避免内存泄漏。
   • 避免返回指向线程栈的指针，因为线程退出后栈空间会被回收。
3. 性能考量：
   • 大量线程频繁 join 可能导致性能开销，可考虑使用线程池减少线程创建 / 销毁次数。

3.5 分离线程

• 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
• 如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。

3.5.1 函数原型与参数

#include <pthread.h>int pthread_detach(pthread_t thread);

• 参数说明：
  • thread：目标线程的标识符（由 pthread_create() 返回）。
• 返回值：
  • 成功时返回 0，失败时返回错误码（如 ESRCH、EINVAL 等）。

3.5.2 基本用法示例

以下代码展示如何将线程设置为分离状态：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>// 线程入口函数
void* background_task(void* arg) {printf("后台任务开始执行...\n");sleep(2);  // 模拟耗时操作printf("后台任务完成\n");pthread_exit(NULL);
}int main() {pthread_t thread_id;// 创建线程if (pthread_create(&thread_id, NULL, background_task, NULL) != 0) {perror("pthread_create failed");return 1;}// 将线程设置为分离状态if (pthread_detach(thread_id) != 0) {perror("pthread_detach failed");return 1;}printf("主线程继续执行，不等待后台任务\n");// 主线程可继续执行其他任务...sleep(5);  // 防止主线程过早退出return 0;
}

3.5.3 核心作用与使用场景

1. 自动资源回收：
   • 分离状态的线程结束后，系统自动回收其资源（如栈空间、线程描述符），无需其他线程干预。
2. 后台任务：
   • 适用于无需返回值的后台任务（如日志记录、监控），避免主线程阻塞等待。
3. 减少资源泄漏风险：
   • 若线程创建后未被 join 或 detach，会成为僵尸线程，占用系统资源。

3.5.4 与 pthread_join() 的对比

特性	pthread_join()	pthread_detach()
资源回收方式	需主动调用，阻塞等待线程结束	线程结束后自动回收
返回值获取	可通过 retval 获取线程返回值	返回值被忽略
线程状态	适用于可连接线程（默认状态）	适用于分离线程
阻塞行为	阻塞调用线程	非阻塞，立即返回
适用场景	需要同步执行结果的场景	后台任务、无需返回值的场景

3.5.5 设置分离状态的两种方式

1. 创建后分离（动态方式）

pthread_t thread_id;
pthread_create(&thread_id, NULL, start_routine, arg);
pthread_detach(thread_id);  // 动态设置为分离状态

2. 创建时分离（静态方式）
   通过线程属性设置：

pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);  // 设置为分离状态
pthread_create(&thread_id, &attr, start_routine, arg);
pthread_attr_destroy(&attr);  // 销毁属性对象

3.5.6 错误处理与常见错误码

• ESRCH：指定的线程 ID 不存在。
• EINVAL：线程已终止，或已被设置为分离状态。

推荐处理方式：

int ret = pthread_detach(thread_id);
if (ret != 0) {fprintf(stderr, "pthread_detach failed, error: %d\n", ret);// 进一步处理...
}

3.5.7 注意事项

1. 无法获取返回值：
   分离状态的线程结束后，其返回值会被丢弃，因此无需通过 pthread_exit() 传递有效返回值。
2. 资源立即释放：
   • 线程结束后，其栈空间、寄存器等资源会立即释放，若其他线程持有指向该线程栈的指针，会导致悬空引用。
3. 避免重复操作：
   • 对同一线程同时调用 pthread_join() 和 pthread_detach() 会导致冲突（通常返回 EINVAL）。
4. 线程状态检查：
   • 无法直接查询线程是否处于分离状态，需通过编程逻辑确保正确设置。

四、线程ID及进程地址空间布局

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

pthread_t到底是什么类型呢？取决于实现。对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。

4.1 pthread_self 函数

4.1.1 函数原型与参数

#include <pthread.h>pthread_t pthread_self(void);

• 参数：无。
• 返回值：
  • 返回调用该函数的线程的 pthread_t 类型标识符。

4.1.2 基本用法示例

以下代码展示如何获取并使用线程 ID：

#include <stdio.h>
#include <pthread.h>void print_thread_id(const char* prefix) {pthread_t tid = pthread_self();printf("%s 线程ID: %lu\n", prefix, (unsigned long)tid);
}// 线程入口函数
void* thread_function(void* arg) {print_thread_id("子线程");// 比较线程IDif (pthread_equal(pthread_self(), *(pthread_t*)arg)) {printf("子线程检测到与传入的线程ID相同\n");} else {printf("子线程检测到与传入的线程ID不同\n");}return NULL;
}int main() {pthread_t thread_id, main_tid;main_tid = pthread_self();  // 获取主线程IDprint_thread_id("主线程");// 创建线程并传入主线程IDif (pthread_create(&thread_id, NULL, thread_function, &main_tid) != 0) {perror("pthread_create failed");return 1;}// 等待子线程结束pthread_join(thread_id, NULL);return 0;
}

4.1.3 核心作用与使用场景

1. 线程身份标识：
   • 在多线程程序中，通过线程 ID 区分不同线程，常用于日志记录或调试。

     printf("线程 %lu 正在处理任务...\n", (unsigned long)pthread_self());
     

2. 线程同步：
   • 在某些同步机制中（如线程特定数据），需使用线程 ID 作为键值。
3. 线程间通信：
   • 在线程间传递消息时，使用线程 ID 指定目标线程。
4. 避免自等待：
   • 在使用 pthread_join() 或 pthread_detach() 时，可通过 pthread_self() 避免线程对自身操作（可能导致死锁）。

     if (!pthread_equal(thread_id, pthread_self())) {pthread_join(thread_id, NULL);  // 确保不等待自身
     }
     

4.1.4 线程 ID 的特性

• 唯一性：
  • 在同一进程内，每个活跃线程的 ID 唯一，但线程终止后，其 ID 可能被新创建的线程复用。
• 不可移植性：
  • pthread_t 的实现因系统而异，可能是整数、指针或结构体，不可直接比较或存储，需使用 pthread_equal() 函数。
• 生命周期：
  • 线程 ID 仅在其生命周期内有效，线程终止后 ID 可能失效。

4.1.5 线程 ID 的比较（pthread_equal）

int pthread_equal(pthread_t t1, pthread_t t2);

• 返回值：
  • 若 t1 和 t2 为同一线程，返回非零值；否则返回 0。
• 示例：

pthread_t tid = pthread_self();
if (pthread_equal(tid, another_thread_id)) {// 是同一线程
}

4.1.6 注意事项

• 避免直接操作线程 ID：
  • 不要假设 pthread_t 是整数类型而直接比较或转换，必须使用 pthread_equal()。
• 线程 ID 的持久化：
  • 不要将线程 ID 存储在全局变量或文件中，因为线程终止后 ID 可能被复用。
• 跨进程无效：
  • 线程 ID 仅在其所属进程内有效，不同进程的线程 ID 无意义。
• 性能考量：
  • pthread_self() 通常是轻量级操作，但频繁调用仍可能影响性能。