当前位置：首页 > article >正文

Linux--线程概念与控制

article 2026/1/24 23:17:16

1. Linux线程概念

1-1 什么是线程

1-2 分⻚式存储管理

1-2-1 虚拟地址和⻚表的由来

1-2-2 物理内存管理

1-2-3 ⻚表

1-2-4 ⻚⽬录结构

1-2-5 两级⻚表的地址转换

1-2-6 缺⻚异常

1-3 线程的优点

1-4 线程的缺点

1-5 线程异常

1-6 线程⽤途

2. Linux进程VS线程

2-1 进程和线程

2-2 进程的多个线程共享

2-3 关于进程线程的问题

3. Linux线程控制

3-1 POSIX线程库

3-2 创建线程

3-3 线程终⽌

3-4 线程等待

3-5 分离线程

4. 线程ID及进程地址空间布局

1. 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。

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 空间的，也许只要⼏⼗个⻚表就可以了。例如：⼀个⽤⼾程序的代码段、数据段、栈段，⼀共就需要 10 MB 的空间，那么使⽤ 3 个⻚表就⾜够了。

计算过程：

每⼀个⻚表项指向⼀个 4KB 的物理⻚，那么⼀个⻚表中 1024 个⻚表项，⼀共能覆盖 4MB 的物理内存; 那么 10MB 的程序，向上对⻬取整之后(4MB 的倍数，就是 12 MB)，就需要 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(Memory Manage 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 处理。

1-3 线程的优点

•

创建⼀个新线程的代价要⽐创建⼀个新进程⼩得多

•

与进程之间的切换相⽐，线程之间的切换需要操作系统做的⼯作要少很多

◦

最主要的区别是线程的切换虚拟内存空间依然是相同的，但是进程切换是不同的。这两种上

下⽂切换的处理都是通过操作系统内核来完成的。内核的这种切换过程伴随的最显著的性能

损耗是将寄存器中的内容切换出。

◦

另外⼀个隐藏的损耗是上下⽂的切换会扰乱处理器的缓存机制。简单的说，⼀旦去切换上下

⽂，处理器中所有已经缓存的内存地址⼀瞬间都作废了。还有⼀个显著的区别是当你改变虚

拟内存空间的时候，处理的⻚表缓冲 TLB （快表）会被全部刷新，这将导致内存的访问在⼀

段时间内相当的低效。但是在线程的切换中，不会出现这个问题，当然还有硬件cache。

•

线程占⽤的资源要⽐进程少很

•

能充分利⽤多处理器的可并⾏数量

•

在等待慢速I/O操作结束的同时，程序可执⾏其他的计算任务

•

计算密集型应⽤，为了能在多处理器系统上运⾏，将计算分解到多个线程中实现

•

I/O密集型应⽤，为了提⾼性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。

1-4 线程的缺点

•

性能损失

◦

⼀个很少被外部事件阻塞的计算密集型线程往往⽆法与其它线程共享同⼀个处理器。如果计

算密集型线程的数量⽐可⽤的处理器多，那么可能会有较⼤的性能损失，这⾥的性能损失指

的是增加了额外的同步和调度开销，⽽可⽤的资源不变。

•

健壮性降低

◦

编写多线程需要更全⾯更深⼊的考虑，在⼀个多线程程序⾥，因时间分配上的细微偏差或者

因共享了不该共享的变量⽽造成不良影响的可能性是很⼤的，换句话说线程之间是缺乏保护

的。

•

缺乏访问控制

◦

进程是访问控制的基本粒度，在⼀个线程中调⽤某些OS函数会对整个进程造成影响。

•

编程难度提⾼

◦

编写与调试⼀个多线程程序⽐单线程程序困难得多

1-5 线程异常

•

单个线程如果出现除零，野指针问题导致线程崩溃，进程也会随着崩溃

•

线程是进程的执⾏分⽀，线程出异常，就类似进程出异常，进⽽触发信号机制，终⽌进程，进程

终⽌，该进程内的所有线程也就随即退出

1-6 线程⽤途

•

合理的使⽤多线程，能提⾼CPU密集型程序的执⾏效率

•

合理的使⽤多线程，能提⾼IO密集型程序的⽤⼾体验（如⽣活中我们⼀边写代码⼀边下载开发⼯

具，就是多线程运⾏的⼀种表现）

2. Linux进程VS线程

2-1 进程和线程

•

进程是资源分配的基本单位

•

线程是调度的基本单位

•

线程共享进程数据，但也拥有⾃⼰的⼀部分数据:

◦

线程ID

◦

⼀组寄存器

◦

栈

◦

errno

◦

信号屏蔽字

◦

调度优先级

2-2 进程的多个线程共享

同⼀地址空间,因此Text Segment、Data Segment都是共享的,如果定义⼀个函数,在各线程中都可以调

⽤,如果定义⼀个全局变量,在各线程中都可以访问到,除此之外,各线程还共享以下进程资源和环境:

•

⽂件描述符表

•

每种信号的处理⽅式(SIG_ IGN、SIG_ DFL或者⾃定义的信号处理函数)

•

当前⼯作⽬录

•

⽤⼾id和组id

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

2-3 关于进程线程的问题

•

如何看待之前学习的单进程？具有⼀个线程执⾏流的进程

3. Linux线程控制

3-1 POSIX线程库

•

与线程有关的函数构成了⼀个完整的系列，绝⼤多数函数的名字都是以“pthread_”打头的

•

要使⽤这些函数库，要通过引⼊头⽂ <pthread.h>

•

链接这些线程函数库时要使⽤编译器命令的“-lpthread”选项

3-2 创建线程

功能：创建⼀个新的线程
原型：
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；失败返回错误码

错误检查:

• 传统的⼀些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指⽰错误。

pthreads函数出错时不会设置全局变量errno（⽽⼤部分其他POSIX函数会这样做）。⽽是将错

误代码通过返回值返回

•

pthreads同样也提供了线程内的errno变量，以⽀持其它使⽤errno的代码。对于pthreads函数的

错误，建议通过返回值业判定，因为读取返回值要⽐读取线程内的errno变量的开销更⼩

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>
void *rout(void *arg) {
int i;
for( ; ; ) {
printf("I'am thread 1\n");
sleep(1);
}
}
int main( void )
{
pthread_t tid;
int ret;
if ( (ret=pthread_create(&tid, NULL, rout, NULL)) != 0 ) {
fprintf(stderr, "pthread_create : %s\n", strerror(ret));
exit(EXIT_FAILURE);
}
int i;
for(; ; ) {
printf("I'am main thread\n");
sleep(1);
}
}
#include <pthread.h>
// 获取线程ID
pthread_t pthread_self(void);

打印出来的 tid 是通过 pthread 库中有函数 pthread_self 得到的，它返回⼀个 pthread_t 类型的

变量，指代的是调⽤ pthread_self 函数的线程的 “ID”。

怎么理解这个“ID”呢？这个“ID”是 pthread 库给每个线程定义的进程内唯⼀标识，是 pthread 库

维持的。

由于每个进程有⾃⼰独⽴的内存空间，故此“ID”的作⽤域是进程级⽽⾮系统级（内核不认识）。

其实 pthread 库也是通过内核提供的系统调⽤（例如clone）来创建线程的，⽽内核会为每个线程创建系统全局唯⼀的“ID”来唯⼀标识这个线程。

使⽤PS命令查看线程信息

运⾏代码后执⾏：

$ ps -aL | head -1 && ps -aL | grep mythread
PID LWP TTY TIME CMD
2711838 2711838 pts/235 00:00:00 mythread
2711838 2711839 pts/235 00:00:00 mythread
-L 选项：打印线程信息

LWP 是什么呢？LWP 得到的是真正的线程ID。之前使⽤ pthread_self 得到的这个数实际上是⼀

个地址，在虚拟地址空间上的⼀个地址，通过这个地址，可以找到关于这个线程的基本信息，包括线

程ID，线程栈，寄存器等属性。

在 ps -aL 得到的线程ID，有⼀个线程ID和进程ID相同，这个线程就是主线程，主线程的栈在虚拟

地址空间的栈上，⽽其他线程的栈在是在共享区（堆栈之间），因为pthread系列函数都是pthread库

提供给我们的。⽽pthread库是在共享区的。所以除了主线程之外的其他线程的栈都在共享区。

3-3 线程终⽌

如果需要只终⽌某个线程⽽不终⽌整个进程,可以有三种⽅法:

1. 从线程函数return。这种⽅法对主线程不适⽤,从main函数return相当于调⽤exit。

2. 线程可以调⽤pthread_ exit终⽌⾃⼰。

3. ⼀个线程可以调⽤pthread_ cancel终⽌同⼀进程中的另⼀个线程。

pthread_exit函数

功能：线程终⽌
原型:
void pthread_exit(void *value_ptr);
参数:
value_ptr:value_ptr不要指向⼀个局部变量。
返回值：
⽆返回值，跟进程⼀样，线程结束的时候⽆法返回到它的调⽤者（⾃⾝）

需要注意,pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是⽤malloc分配的,

不能在线程函数的栈上分配,因为当其它线程得到这个返回指针时线程函数已经退出了。

pthread_cancel函数

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

3-4 线程等待

为什么需要线程等待？

•

已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。

•

创建新的线程不会复⽤刚才退出线程的地址空间。

功能：等待线程结束
原型
int pthread_join(pthread_t thread, void **value_ptr);
参数:
thread:线程ID
value_ptr:它指向⼀个指针，后者指向线程的返回值
返回值：成功返回0；失败返回错误码

调⽤该函数的线程将挂起等待,直到id为thread的线程终⽌。thread线程以不同的⽅法终⽌,通过

pthread_join得到的终⽌状态是不同的，总结如下:

1. 如果thread线程通过return返回,value_ ptr所指向的单元⾥存放的是thread线程函数的返回值。

2. 如果thread线程被别的线程调⽤pthread_ cancel异常终掉,value_ ptr所指向的单元⾥存放的是常

数PTHREAD_ CANCELED。

3. 如果thread线程是⾃⼰调⽤pthread_exit终⽌的,value_ptr所指向的单元存放的是传给

pthread_exit的参数。

4. 如果对thread线程的终⽌状态不感兴趣,可以传NULL给value_ ptr参数。

3-5 分离线程

•

默认情况下，新创建的线程是joinable的，线程退出后，需要对其进⾏pthread_join操作，否则

⽆法释放资源，从⽽造成系统泄漏。

•

如果不关⼼线程的返回值，join是⼀种负担，这个时候，我们可以告诉系统，当线程退出时，⾃

动释放线程资源

int pthread_detach(pthread_t thread);
可以是线程组内其他线程对⽬标线程进⾏分离，也可以是线程⾃⼰分离:
pthread_detach(pthread_self());

joinable和分离是冲突的，⼀个线程不能既是joinable⼜是分离的。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread_run( void * arg )
{
pthread_detach(pthread_self());
printf("%s\n", (char*)arg);
return NULL;
}
int main( void )
{
pthread_t tid;
if ( pthread_create(&tid, NULL, thread_run, "thread1 run...") != 0 ) {
printf("create thread error\n");
return 1;
}
int ret = 0;
sleep(1);//很重要，要让线程先分离，再等待
if ( pthread_join(tid, NULL ) == 0 ) {
printf("pthread wait success\n");
ret = 0;
} else {
printf("pthread wait failed\n");
ret = 1;
}
return ret;
}

4. 线程ID及进程地址空间布局

•

pthread_ create函数会产⽣⼀个线程ID，存放在第⼀个参数指向的地址中。该线程ID和前⾯说的

线程ID不是⼀回事。

•

前⾯讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最⼩单位，

所以需要⼀个数值来唯⼀表⽰该线程。

•

pthread_ create函数第⼀个参数指向⼀个虚拟内存单元，该内存单元的地址即为新创建线程的线

程ID，属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。

•

线程库NPTL提供了pthread_ self函数，可以获得线程⾃⾝的ID：

pthread_t pthread_self(void);

pthread_t 到底是什么类型呢？取决于实现。对于Linux⽬前实现的NPTL实现⽽⾔，pthread_t类

型的线程ID，本质就是⼀个进程地址空间上的⼀个地址。

1. Linux线程概念

1-1 什么是线程

1-2 分⻚式存储管理

1-2-1 虚拟地址和⻚表的由来

1-2-2 物理内存管理

1-2-3 ⻚表

1-2-4 ⻚⽬录结构

1-2-5 两级⻚表的地址转换

1-2-6 缺⻚异常

1-3 线程的优点

1-4 线程的缺点

1-5 线程异常

1-6 线程⽤途

2. Linux进程VS线程

2-1 进程和线程

2-2 进程的多个线程共享

2-3 关于进程线程的问题

3. Linux线程控制

3-1 POSIX线程库

3-2 创建线程

3-3 线程终⽌

3-4 线程等待

3-5 分离线程

4. 线程ID及进程地址空间布局

相关文章：