
大家好,欢迎来到 huangjin007_ 的博客
⭐ 个人主页:huangjin007_
🔥 文章收录专栏:Linux 内功修炼手册(系统篇)
总会有一些坚持
能从冰封的土地里
培育出十万朵怒放的蔷薇
Linux 系统篇(四十一) ------ 线程的优缺点、资源共享与上下文切换
文章目录
- [Linux 系统篇(四十一) ------ 线程的优缺点、资源共享与上下文切换](#Linux 系统篇(四十一) —— 线程的优缺点、资源共享与上下文切换)
-
- 一、线程的优缺点
-
- [1. 线程的优点](#1. 线程的优点)
- [2. 线程的缺点](#2. 线程的缺点)
- 二、一个线程出错,为什么可能导致整个进程退出?
- 三、线程之间究竟共享什么?
-
- [1. 线程共享与独占的资源](#1. 线程共享与独占的资源)
- 四、一个进程可以只有一个线程吗?
- 五、线程共享地址空间,究竟意味着什么?
- 六、为什么数组越界不一定发生段错误?
- 七、线程切换为什么通常比进程切换更轻量?
-
- [1. 线程切换](#1. 线程切换)
- [2. 进程切换](#2. 进程切换)
- [3. 两者对比](#3. 两者对比)
- 八、线程的生命周期
- 九、重点总结
- 结语:
一、线程的优缺点
1. 线程的优点
(1)创建和销毁的开销较小
创建一个进程时,操作系统需要为它建立相应的管理结构和资源环境。
而线程运行在已有进程的地址空间中,创建线程通常不需要重新建立一套完整的进程地址空间,因此开销相对较小。
(2)线程切换的开销较小
同一个进程中的多个线程共享地址空间。
当 CPU 在这些线程之间切换时,虽然仍然需要保存和恢复各自的执行上下文,但通常不需要切换进程地址空间,因此切换开销一般小于进程切换。
具体为什么会这样,我们在后面会详细分析。
(3)占用的资源相对较少
多个线程可以共享同一个进程的大部分资源,不需要为每个线程都准备一套独立的进程资源。
这样一来,创建多个线程通常比创建多个独立进程更加节省资源。
(4)能够充分利用多核 CPU
一个进程中可以创建多个线程。当系统具有多个 CPU 核心时,多个线程可以在不同核心上同时运行,从而提高程序的执行效率。
这里举两个比较常见的例子:
- I/O 密集型任务:线程可以在等待 I/O 的过程中,让其他线程继续执行,不必让 CPU 一直干等着。
- CPU 密集型任务:可以将计算任务分配给多个线程,在多核 CPU 上并行处理。
2. 线程的缺点
线程虽然有不少优势,但也不是线程越多,程序运行得就越快。
如果不考虑实际情况,一味地创建线程,最后可能只是给操作系统增加工作量。
(1)线程过多会带来额外开销
线程的创建、调度和切换都需要消耗资源。
如果线程数量过多,CPU 就需要花费更多时间进行线程管理,反而可能降低程序效率。
所以,线程数量并不是越多越好,合理分配才是关键。
(2)健壮性较低
同一个进程中的线程共享地址空间,一个线程如果错误地修改了共享数据,就可能影响其他线程。
更严重的是,一个线程发生某些致命错误时,可能导致整个进程终止。
(3)缺少进程级别的访问隔离
同一进程中的线程共享地址空间,通常可以访问进程中的大部分内存数据。
这意味着线程之间不像独立进程那样具有地址空间隔离。如果一个线程出现错误操作,就可能影响其他线程的数据。
(4)编程和调试更加困难
多个线程可能同时执行,而且执行顺序具有不确定性。
如果多个线程同时访问共享数据,就可能出现数据竞争、死锁等问题。
有时候程序运行十次都没有问题,第十一次却突然出现异常。遇到这种情况,调试起来可就没那么轻松了。
二、一个线程出错,为什么可能导致整个进程退出?
这里我们先思考一个问题:
假设一个进程中有三个线程,其中一个线程运行时发生了严重错误,那么另外两个线程还能继续运行吗?
答案是:不一定,某些致命错误会导致整个进程终止。
例如,一个线程访问了不允许访问的内存,触发了 SIGSEGV 信号。
在 Linux 中,如果该信号按照默认方式处理,通常会终止整个进程,而不是只终止发生错误的线程。
为什么会这样?
因为线程虽然拥有各自独立的执行流,但它们仍然属于同一个进程,共享进程的地址空间等资源。
当某些致命信号按照默认方式处理时,操作系统会终止整个进程,进程中的其他线程自然也无法继续运行。
不过,这里有几个容易混淆的地方:
- 一个线程正常执行
return,通常只会结束当前线程。- 调用
pthread_exit(),也只会结束调用它的线程。- 某些致命信号按照默认方式处理时,可能终止整个进程。
所以,不要认为一个线程结束了,就意味着整个进程也结束了。线程的退出和进程的退出是两回事。
三、线程之间究竟共享什么?
既然多个线程属于同一个进程,那么它们之间必然存在资源共享。
但问题来了:是不是同一个进程中的所有线程,共享的东西都完全一样呢?
当然不是。
线程之间有些资源是共享的,有些资源则必须独立保存。否则多个线程同时执行时,连各自的执行状态都无法区分了。
1. 线程共享与独占的资源
先来看一张表:
| 共享的资源 | 独占的资源 |
|---|---|
| 虚拟地址空间 | 线程 ID |
| 全局变量、静态变量 | 寄存器上下文 |
| 堆内存 | 线程栈 |
| 文件描述符表 | 错误码 errno |
| 信号处理方式 | 信号屏蔽字 |
| 当前工作目录 | 调度相关信息 |
| 用户 ID、组 ID | 线程局部数据 |
表格中的内容比较多,不需要一口气全部背下来。我们挑几个比较重要的地方理解一下。
(1)共享地址空间
同一个进程中的线程共享地址空间,因此一个线程对全局变量的修改,其他线程通常也能够看到。
例如:
cpp
int g_val = 100;
void* thread1(void* arg)
{
g_val = 200;
return nullptr;
}
void* thread2(void* arg)
{
std::cout << g_val << std::endl;
return nullptr;
}
两个线程访问的是同一个全局变量 g_val,而不是各自拥有一份副本。
如果 thread1 已经将 g_val 修改为 200,那么 thread2 访问的也是这个被修改后的共享变量。
当然,如果两个线程同时读写这个变量,就需要考虑线程同步问题。毕竟共享数据虽然方便,但也不能完全放任不管。
(2)线程拥有独立的栈
虽然线程共享地址空间,但是每个线程都有自己的栈。
栈中保存着函数调用过程中需要使用的数据,例如局部变量、函数参数和返回地址等。
那么,为什么每个线程都需要独立的栈呢?
想象一下,如果多个线程共用同一个栈,它们可能同时调用不同的函数,函数调用过程中保存的数据就可能互相覆盖。
这样一来,一个线程刚保存好的局部变量,可能就被另一个线程改掉了,程序自然无法正常执行。
所以,每个线程都需要自己的栈,用来保存属于自己的函数调用信息。
(3)线程拥有独立的寄存器上下文
CPU 执行线程时,需要使用寄存器保存当前执行状态。
当线程被切换出去时,操作系统需要保存它的执行上下文;当线程再次获得 CPU 时,再恢复相应的上下文。
这样线程才能从之前暂停的位置继续执行,而不是每次重新从头开始。
(4)文件描述符表是共享的
我们之前学习过文件操作,知道进程可以通过 open() 打开文件,并获得对应的文件描述符 fd。
那么,如果一个线程打开了文件,其他线程能不能使用这个文件描述符呢?
可以。
因为同一个进程中的线程共享文件描述符表,所以一个线程打开文件后,其他线程也可以使用对应的文件描述符。
不过,共享文件描述符不代表多个线程可以随意并发修改文件操作状态,具体操作仍然需要考虑同步问题。
四、一个进程可以只有一个线程吗?
当然可以!
一个进程至少需要有一个线程来执行程序代码。
如果一个进程中只有一个线程,那么它就是我们通常所说的单线程进程。
如果一个进程中有多个线程,那么它就是多线程进程。
所以,我们可以这样理解:
线程是进程内部的执行流,一个进程可以拥有一个或多个线程。
五、线程共享地址空间,究竟意味着什么?
前面我们提到,同一个进程中的线程共享虚拟地址空间。
这里结合上一篇学习过的虚拟内存知识,再理解一个重要结论:
同一个进程中的多个线程共享同一套进程地址空间管理结构和页表,而不是每个线程都创建一套独立的页表。
在 Linux 中,进程的地址空间由 mm_struct 等内核数据结构管理,虚拟地址到物理地址的映射则由页表完成。
同一个进程中的线程共享这套地址空间,因此:
- 一个线程申请的堆内存,其他线程也可以访问。
- 一个线程修改全局变量,其他线程也可以看到。
- 一个线程创建的动态内存对象,其他线程也可以访问。
这也是为什么线程之间可以方便地共享数据。
不过,线程的栈等执行资源仍然是独立的。
所以,不要把线程的资源划分简单理解为给每个线程分配一套新的页表。
线程之间共享的是进程的地址空间,而不是各自拥有一份独立的进程地址空间。
六、为什么数组越界不一定发生段错误?
这里有一个很有意思的问题。
我们知道,在 C/C++ 中,数组不能越界访问,否则就属于未定义行为。
但是,如果真的发生了数组越界,程序一定会崩溃吗?
答案是:不一定。
例如:
cpp
#include <iostream>
using namespace std;
int main()
{
int arr[10] = {0};
arr[10] = 100;
cout << "hello world" << endl;
return 0;
}
这里数组只有 10 个元素,下标范围是 0~9。
但是我们却访问了 arr[10],很明显已经越界了。
奇怪的是,有时候运行这段代码,程序依然能够正常输出:
text
hello world
难道数组越界也没什么大不了的?
当然不是。只是这次程序没有立刻崩溃而已。
原因在于:操作系统的内存保护通常是以页为单位进行的,而不是以 C++ 数组为单位进行的。
例如,数组所在的内存页可能还包含其他可访问的数据。
当程序访问 arr[10] 时,如果对应的内存地址仍然位于一个已经映射且具有相应访问权限的页面中,那么 CPU 不一定会触发内存访问异常。
但是,这并不意味着访问合法。
因为从 C++ 语言的角度来看,数组越界属于未定义行为。
程序可能表现为正常运行、数据被破坏,也可能发生崩溃。具体会出现什么结果,并没有保证。
所以,这里记住三个结论:
- 数组越界不一定触发段错误。
- 页级内存保护无法直接识别 C++ 数组的边界。
- 数组越界属于未定义行为,不能因为程序暂时没有崩溃,就认为代码正确。
七、线程切换为什么通常比进程切换更轻量?
前面我们已经知道,同一个进程中的线程共享地址空间。
那么,这种共享到底给线程切换带来了什么好处?
我们分别来看一下线程切换和进程切换。
1. 线程切换
假设一个进程中有两个线程:
- 线程 A
- 线程 B
当 CPU 从线程 A 切换到线程 B 时,需要保存线程 A 的执行上下文,并恢复线程 B 的执行上下文。
例如:
- 保存和恢复寄存器状态。
- 切换到对应线程的栈。
- 恢复线程的执行位置。
这些操作都是需要的,线程切换并不是完全没有成本。
但是,由于两个线程属于同一个进程,它们共享地址空间。
因此,通常不需要切换到另一套进程地址空间,也不需要为线程 B 加载一套全新的页表。
2. 进程切换
再来看进程切换。
假设 CPU 从进程 A 切换到进程 B。
两个进程通常拥有各自独立的地址空间。
所以,除了保存和恢复执行上下文之外,还需要处理地址空间的切换。
地址空间发生变化时,TLB 中的地址转换缓存也可能需要相应处理。
这就比同一个进程内的线程切换多了一部分工作。
3. 两者对比
我们把它们放在一起看:
| 对比内容 | 同一进程内的线程切换 | 不同进程之间的切换 |
|---|---|---|
| 保存和恢复执行上下文 | 需要 | 需要 |
| 切换执行栈 | 需要 | 需要 |
| 地址空间切换 | 通常不需要 | 通常需要 |
| 页表切换 | 通常不需要 | 通常需要处理 |
| TLB 相关处理 | 通常较少 | 可能需要更多处理 |
这样就比较清楚了。
线程切换和进程切换都需要保存、恢复执行状态,真正重要的区别在于:同一进程内的线程通常共享地址空间,因此不需要像不同进程切换那样处理地址空间切换。
八、线程的生命周期
前面我们一直在讨论线程拥有哪些资源、线程之间如何共享资源。
那么,一个线程从创建到结束,究竟会经历哪些过程呢?
其实,线程并不是创建出来之后就一直运行到结束的。在运行过程中,它可能会等待 CPU,也可能因为等待某些资源而暂时停下来。
一个线程通常会经历以下状态:
- 创建: 操作系统创建线程。
- 就绪: 线程已经具备运行条件,等待 CPU 调度。
- 运行: 线程获得 CPU,开始执行代码。
- 阻塞: 线程因为等待某些资源或事件而暂时无法继续执行。
- 终止: 线程执行结束。
九、重点总结
这一篇的知识点有点多,不过不用担心,我们把最重要的内容整理一下。
| 知识点 | 需要记住的内容 |
|---|---|
| 线程的优点 | 创建开销小、切换开销相对较小、资源占用少、能够利用多核 |
| 线程的缺点 | 线程过多会增加开销、健壮性较低、编程调试困难 |
| 线程共享资源 | 地址空间、全局变量、堆、文件描述符表等 |
| 线程独占资源 | 线程 ID、寄存器上下文、栈、errno、信号屏蔽字等 |
| 线程异常 | 某些致命错误可能导致整个进程终止 |
| 数组越界 | 不一定发生段错误,但属于未定义行为 |
| 线程切换 | 同一进程内的线程通常不需要切换地址空间 |
| 进程切换 | 不同进程之间通常需要切换地址空间 |
到这里,我们就把线程的优缺点、资源共享以及上下文切换梳理完了。
结语:
今天的内容到这里就结束了,希望你能有所收获~
干货整理到手抖,觉得有用的话,赏个三连回回血?__(:ᗤ」ㄥ)_ _