Update 计算机操作系统 - 进程管理.md

补充线程拥有的少量资源、虚拟线程卸载与堆占用、管程中条件变量的命名、管道写端的关闭和信号量跨进程共享的方式,附录 A2 补充不同执行方式下的实测。
This commit is contained in:
CyC2018
2026-11-07 17:10:30 +08:00
parent da990e5aae
commit c3984a9aaa
+21 -19
View File
@@ -68,10 +68,10 @@ QQ 和浏览器是两个进程,浏览器进程里面有很多线程,例如 H
### 3. 区别 🔥🔥
- 拥有资源:进程是资源分配的基本单位,但是线程不拥有资源,线程可以访问隶属进程的资源;
- 拥有资源:进程是资源分配的基本单位,线程基本不拥有系统资源,只有栈、寄存器等运行所必需的少量资源,可以访问隶属进程的资源;
- 调度:线程是独立调度的基本单位,在同一进程中,线程的切换不会引起进程切换,从一个进程中的线程切换到另一个进程中的线程时,会引起进程切换;
- 系统开销:由于创建或撤销进程时,系统都要为之分配或回收资源,如内存空间、I/O 设备等,所付出的开销远大于创建或撤销线程时的开销。类似地,两者切换时都要保存和恢复寄存器,进程切换还要切换地址空间,开销更大(见[上下文切换](#4-上下文切换));
- 通信方面:线程间可以通过直接读写同一进程中的数据进行通信,但要用互斥量、信号量等手段同步(见[进程同步](#进程同步)),进程通信则需要借助 IPC;
- 通信方面:线程间可以通过直接读写同一进程中的数据进行通信,但要用互斥量、信号量等手段同步(见[进程同步](#进程同步)),进程通信则需要借助管道、共享存储、套接字等进程间通信(Inter-Process Communication, IPC)机制(见[进程通信](#进程通信));
- 健壮性:进程之间相互隔离,一个进程崩溃不影响其它进程,而一个线程访问非法内存触发段错误时,SIGSEGV 信号虽然发给出错的线程,默认动作却是终止整个进程,其它线程也一起结束。
在 Linux 内核中,进程和线程都用 task_struct 表示,都是调度的对象,区别只在于和创建者共享了多少资源。fork 和 pthread_create 最终都调用 clone 或 clone3 系统调用,只是传入的标志不同(strace 实测,见[附录 A4](#a4-fork-与-pthread_create-的-clone-标志)):
@@ -83,7 +83,7 @@ pthread_create() clone(flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_
CLONE_VM 表示共享地址空间,CLONE_FILES 表示共享文件描述符表,CLONE_THREAD 表示加入创建者的线程组。没有这些标志时,子进程得到一份地址空间的副本([写时复制](计算机操作系统%20-%20内存管理.md#分页系统地址映射)),修改全局变量不影响父进程;有这些标志时,新线程修改的就是同一个变量。getpid() 返回的是线程组 ID,同一进程中的线程都相同,gettid() 返回每个线程自己的 ID,top -H、ps -L 中看到的就是它。
fork 调用一次、返回两次:父进程中返回子进程的 PID,子进程中返回 0。多线程的进程 fork 后,子进程中只有调用 fork 的那个线程,但互斥量等对象的状态也被复制过来。如果复制时某个只在进程内使用的互斥量正被其它线程持有,子进程中没有线程会释放它,再加锁就可能死锁。所以子进程通常尽快调用 exec,在此之前只调用异步信号安全的函数。
fork 调用一次、返回两次:父进程中返回子进程的 PID,子进程中返回 0。多线程的进程 fork 后,子进程中只有调用 fork 的那个线程,但互斥量等对象的状态也被复制过来。如果复制时某个只在进程内使用的互斥量正被其它线程持有,子进程中没有线程会释放它,再加锁就可能死锁。所以子进程通常尽快调用 exec,在此之前只调用异步信号安全的函数(可以在信号处理函数中安全调用的函数,例如 write、_exit,printf 不在其中)。
<div align="center"> <img src="pics/process-vs-thread.png" width="760px"/> </div><br>
@@ -100,9 +100,9 @@ fork 调用一次、返回两次:父进程中返回子进程的 PID,子进
- 线程主动阻塞,例如等待 I/O、等待锁、调用 sleep();
- 更高优先级的线程进入就绪状态。
需要注意的是,系统调用只是从用户态进入内核态,执行完后通常回到同一个线程,不一定发生上下文切换。
需要注意的是,系统调用只是从[用户态进入内核态](计算机操作系统%20-%20概述.md#系统调用),执行完后通常回到同一个线程,不一定发生上下文切换。
同一进程中的线程切换不需要换地址空间;切换到另一个进程时还要切换页表。x86 的 PCID、ARM 的 ASID 可以给 TLB 表项标上所属的地址空间,切换页表时不必清空整个 TLB,切回来时原来的映射可能还在;没有这类标记时,每次切换页表都会清空 TLB 中除全局页(内核映射)以外的表项,之后访问内存要重新查页表。切换之后 TLB 和 CPU 缓存的未命中还会增加执行时间,增加多少取决于硬件和两个执行流各自访问的数据量,同一进程的线程切换也可能发生缓存未命中。
同一进程中的线程切换不需要换地址空间;切换到另一个进程时还要切换页表。x86 的 PCID、ARM 的 ASID 可以给[快表(TLB)](计算机操作系统%20-%20内存管理.md#分页系统地址映射)表项标上所属的地址空间,切换页表时不必清空整个 TLB,切回来时原来的映射可能还在;没有这类标记时,每次切换页表都会清空 TLB 中除全局页(内核映射)以外的表项,之后访问内存要重新查页表。切换之后 TLB 和 CPU 缓存的未命中还会增加执行时间,增加多少取决于硬件和两个执行流各自访问的数据量,同一进程的线程切换也可能发生缓存未命中。
例如把两个执行流固定在同一个 CPU 上,通过两根管道来回传 1 个字节,让它们交替运行,两个线程之间、两个进程之间每次切换都约 1.1 微秒,其中还包含一次 write 和一次 read 系统调用(Linux 实测,见[附录 A1](#a1-上下文切换))。数据量很小时两者几乎没有差别。线程过多、频繁阻塞时,CPU 会把相当一部分时间花在切换上,可以用 vmstat 的 cs 列或 pidstat -w 观察每秒的切换次数。
@@ -120,7 +120,7 @@ Go 的 GMP 模型是一个典型实现:G 是 goroutine,M 是系统线程,P
与线程相比:
- 切换在用户态完成,只需要保存少量寄存器,不需要陷入内核,开销小,例如 goroutine 每次切换约 0.1~0.2 微秒,虚拟线程约 0.3 微秒,线程约 1.1 微秒(测法不同,只比较数量级,见[附录 A6](#a6-协程的切换开销)、[附录 A1](#a1-上下文切换));
- 切换在用户态完成,不需要陷入内核:goroutine 只保存栈指针、程序计数器等几个寄存器,虚拟线程卸载(离开所在的平台线程,见下文)时把栈帧复制到堆中,开销都小,例如 goroutine 每次切换约 0.1~0.2 微秒,虚拟线程约 0.3 微秒,线程约 1.1 微秒(测法不同,只比较数量级,见[附录 A6](#a6-协程的切换开销)、[附录 A1](#a1-上下文切换));
- 占用的内存少,可以同时存在大量协程,而每个线程都要预留独立的栈,例如 Linux x64 上 Java 线程的栈默认为 1 MB(ARM64 的 Linux 和 macOS 上为 2 MB),线程数量有限;
- 同一个线程上的协程不能并行执行,要利用多核仍然需要多个线程;协程中如果执行了运行时没有改写的阻塞系统调用(例如读本地文件),所在的线程仍会被阻塞。
@@ -128,14 +128,14 @@ Go 的 GMP 模型是一个典型实现:G 是 goroutine,M 是系统线程,P
Java 21 正式引入的虚拟线程([JEP 444](https://openjdk.org/jeps/444))就是 JVM 实现的协程:虚拟线程由 JVM 调度到少量的平台线程(称为载体线程,carrier thread)上运行,执行阻塞 I/O 时从平台线程上卸载,让平台线程去执行其它虚拟线程。调度器是一个工作窃取的 ForkJoinPool,平台线程数默认等于 CPU 核数,JDK 21 不按时间片抢占虚拟线程。
虚拟线程卸载时,它的栈帧以栈块对象(stack chunk)的形式保存在堆中,等 I/O 就绪后再挂载到某个平台线程上继续执行,所以阻塞的虚拟线程只占用与调用深度相当的堆内存,不占用平台线程。虚拟线程的创建成本很低,不需要用线程池复用,需要限制并发数时使用信号量。在 JDK 21 中,虚拟线程在 synchronized 块内阻塞时无法卸载,会固定(pinning)在载体线程上。读写文件、Object.wait() 同样会占住载体线程,但调度器会临时增加平台线程来补偿;pinning 没有补偿,载体线程被占满后其它虚拟线程都无法执行,所以锁内有阻塞操作时改用 ReentrantLock(见 [Java 并发](Java%20并发.md#使用选择));JDK 24 起([JEP 491](https://openjdk.org/jeps/491))基本消除了这个限制。
虚拟线程卸载时,它的栈帧以栈块对象(stack chunk)的形式保存在堆中,等 I/O 就绪后再挂载到某个平台线程上继续执行,所以阻塞的虚拟线程只占用与调用深度相当的堆内存,不占用平台线程。虚拟线程的创建成本很低,不需要用线程池复用,需要限制并发数时使用信号量。在 JDK 21 中,虚拟线程在 synchronized 块内阻塞时无法卸载,会固定(pinning)在载体线程上。读写文件、Object.wait() 同样会占住载体线程,但调度器会临时增加平台线程来补偿;pinning 没有补偿,载体线程被占满后其它虚拟线程都无法执行,所以锁内有阻塞操作时改用 ReentrantLock(见 [Java 并发](Java%20并发.md#使用选择));JDK 24 起([JEP 491](https://openjdk.org/jeps/491))基本消除了这个限制,Object.wait() 也改为卸载。需要注意的是,JDK 23 起读写文件时调度器不再补偿(直接 I/O 等少数情况除外)。
<div align="center"> <img src="pics/virtual-thread-unmount.png" width="760px"/> </div><br>
例如在 JDK 21 中启动 1 万个阻塞在同一个 CountDownLatch 上的线程(Ubuntu 24.04 容器实测,见[附录 A2](#a2-平台线程与虚拟线程的开销)):
- 平台线程用时约 1.4 秒,进程的常驻内存增加约 290 MB,平均每个约 30 KB,这是因为 2 MB(aarch64)的栈只是预留的虚拟地址,用到的页才占用物理内存;
- 虚拟线程用时约 30 毫秒,每个只在堆中占用约 2 KB;启动 100 万个虚拟线程用时约 0.5 秒,堆中共占用约 690 MB。
- 虚拟线程用时约 30 毫秒,每个只在堆中占用约 2 KB;启动 100 万个虚拟线程用时约 0.5 秒,堆中共占用约 690 MB,平均每个约 0.7 KB,比 1 万个时少,每个虚拟线程的堆占用不是固定值,还受代码执行方式的影响(见[附录 A2](#a2-平台线程与虚拟线程的开销))。
协程也不能无限创建:每个协程的栈和状态都要占内存,例如把最大堆设为 256 MB 时,启动 100 万个阻塞的虚拟线程会抛出 OutOfMemoryError。协程适合大量任务都在等待 I/O 的场景,例如每个请求都要调用下游接口、查询数据库;CPU 密集的任务没有等待可以让出,开再多协程也只能由少量线程轮流执行,不会更快。
@@ -221,7 +221,7 @@ Linux 的进程状态和僵尸进程、孤儿进程见 [Linux](Linux.md#进程
分为硬实时和软实时,前者必须满足绝对的截止时间,后者可以容忍一定的超时。
实际的操作系统会组合使用这些思想。例如 Linux 2.6.23 起的完全公平调度器(CFS)给每个进程记录按优先级加权后的虚拟运行时间,总是选择虚拟运行时间最小的进程运行,让各进程按权重分享 CPU;Linux 6.6 起开始改用 EEVDF 调度器,同样按权重公平分享,但只在还没有用超自己份额的进程中选择,选其中虚拟截止时间最早的运行;虚拟运行时间和权重相同时,请求的时间片越短,虚拟截止时间越早,有利于对延迟敏感的进程更快得到运行。实时进程使用单独的 SCHED_FIFO、SCHED_RR 策略,优先于普通进程。
实际的操作系统会组合使用这些思想。例如 Linux 2.6.23 起的完全公平调度器(CFS)给每个进程记录按优先级加权后的虚拟运行时间,总是选择虚拟运行时间最小的进程运行,让各进程按权重分享 CPU;Linux 6.6 起开始改用 EEVDF 调度器,同样按权重公平分享,但只在还没有用超自己份额的进程中选择,选其中虚拟截止时间(虚拟运行时间加上请求的时间片除以权重)最早的运行;虚拟运行时间和权重相同时,请求的时间片越短,虚拟截止时间越早,有利于对延迟敏感的进程更快得到运行。实时进程使用单独的 SCHED_FIFO、SCHED_RR 策略,优先于普通进程。
## 进程同步
@@ -265,7 +265,7 @@ Linux 的进程状态和僵尸进程、孤儿进程见 [Linux](Linux.md#进程
down 和 up 操作需要被设计成原语,不可分割。单处理器上通常在执行这些操作时屏蔽中断;多处理器上屏蔽中断只对本 CPU 有效,还要用 TSL、CAS 这类原子指令保护信号量。
如果信号量的取值只能为 0 或者 1,就称为二值信号量,可以当作互斥量(Mutex)使用,0 表示临界区已经加锁,1 表示临界区解锁。需要注意的是,信号量可以由另一个进程执行 up,而 pthread_mutex、ReentrantLock 这类互斥锁只能由加锁的线程释放,所以后面读者-写者问题中由第一个读者 down、最后一个读者 up 的 data_mutex 不能换成互斥锁。
如果信号量的取值只能为 0 或者 1,就称为二值信号量,可以当作互斥量(Mutex)使用,0 表示临界区已经加锁,1 表示临界区解锁。需要注意的是,信号量可以由另一个进程执行 up,而 pthread_mutex、ReentrantLock 这类互斥锁只能由加锁的线程释放,所以后面[读者-写者问题](#2-读者-写者问题)中由第一个读者 down、最后一个读者 up 的 data_mutex 不能换成互斥锁。
```c
typedef int semaphore;
@@ -316,16 +316,16 @@ void consumer() {
down(&full);
down(&mutex);
int item = remove_item();
consume_item(item);
up(&mutex);
up(&empty);
consume_item(item);
}
}
```
### 4. 管程
使用信号量机制实现的生产者消费者问题需要客户端代码做很多控制,而管程把控制的代码独立出来,不仅不容易出错,也使得客户端代码调用更容易。
使用信号量机制实现的生产者消费者问题需要客户端代码做很多控制,而管程(Monitor)把共享数据和操作它的过程封装在一起,把控制的代码独立出来,不仅不容易出错,也使得客户端代码调用更容易。
C 语言不支持管程,下面的示例代码使用了类 Pascal 语言来描述管程。示例代码的管程提供了 insert() 和 remove() 方法,客户端代码通过调用这两个方法来解决生产者-消费者问题。
@@ -396,7 +396,7 @@ begin
end;
```
上面的伪代码用 if 检查条件,前提是被 signal 唤醒的进程立即运行。Java 的每个对象都可以当作管程,synchronized 保证互斥,wait()、notify() 相当于条件变量的 wait 和 signal,但被唤醒的线程要重新竞争锁,条件可能已经变了,所以要用 while 检查(见 [Java 并发](Java%20并发.md#wait-notify-notifyall))。
管程中的条件变量按等待的原因命名:缓冲区满时生产者在 full 上等待,缓冲区空时消费者在 empty 上等待,与前面信号量中 full、empty 表示缓冲区个数的含义不同。上面的伪代码用 if 检查条件,前提是被 signal 唤醒的进程立即运行。Java 的每个对象都可以当作管程,synchronized 保证互斥,wait()、notify() 相当于条件变量的 wait 和 signal,但被唤醒的线程要重新竞争锁,条件可能已经变了,所以要用 while 检查(见 [Java 并发](Java%20并发.md#wait-notify-notifyall))。
## 经典同步问题
@@ -440,7 +440,7 @@ void philosopher(int i) {
typedef int semaphore;
int state[N]; // 跟踪每个哲学家的状态
semaphore mutex = 1; // 临界区的互斥,临界区是 state 数组,对其修改需要互斥
semaphore s[N]; // 每个哲学家一个信号量
semaphore s[N]; // 每个哲学家一个信号量,初值为 0
void philosopher(int i) {
while(TRUE) {
@@ -550,7 +550,7 @@ int pipe(int fd[2]);
<div align="center"> <img src="pics/pipe.png" width="740px"/> </div><br>
fork 后父子进程要关闭各自不用的一端:只要还有一个写端没关闭,读完数据的 read 就会一直阻塞,所有写端都关闭后 read 才返回 0。管道容量有限(Linux 默认 16 页,页大小为 4 KB 时是 64 KB),写满时 write 也会阻塞。
fork 后父子进程要关闭各自不用的一端:只要还有一个写端没关闭(包括读进程自己从 fork 继承的那个),读完数据的 read 就会一直阻塞,所有写端都关闭后 read 才返回 0。管道容量有限(Linux 默认 16 页,页大小为 4 KB 时是 64 KB),写满时 write 也会阻塞。
### 2. FIFO
@@ -574,17 +574,17 @@ FIFO 常用于客户-服务器应用程序中,FIFO 用作汇聚点,在客户
- 按消息读写,保留消息的边界,而 FIFO 是字节流,接收方要自己拆分;
- 读进程可以根据消息类型有选择地接收消息,而不像 FIFO 那样只能按顺序接收。
每条消息都要在进程和内核之间复制两次,不适合传输大量数据。
每条消息都要复制两次:发送时从发送进程复制到内核,接收时再从内核复制到接收进程,不适合传输大量数据。
### 4. 信号量
它是一个计数器,用于为多个进程提供对共享数据对象的访问,P、V 操作与[信号量](#3-信号量)一节相同。
它是一个计数器,用于为多个进程提供对共享数据对象的访问,P、V 操作与[信号量](#3-信号量)一节相同。不同进程要使用同一个信号量,它必须放在各进程都能访问的地方:POSIX 的有名信号量由各进程用同一个名字调用 sem_open 打开,无名信号量要放在共享内存中,例如下文共享存储的例子。
### 5. 共享存储
允许多个进程共享一个给定的存储区。因为数据不需要在进程之间复制,所以这是最快的一种 IPC。
管道每传一次数据要复制两次:write 把数据从写进程复制到内核缓冲区,read 再复制到读进程。共享内存把同一个物理页框映射到两个进程的地址空间,写进程写入后,读进程直接就能读到。
管道每传一次数据要复制两次:write 把数据从写进程复制到内核缓冲区,read 再复制到读进程。共享内存把同一个物理[页框](计算机操作系统%20-%20内存管理.md#虚拟内存)映射到两个进程的地址空间,写进程写入后,读进程直接就能读到。
<div align="center"> <img src="pics/ipc-shm.png" width="740px"/> </div><br>
@@ -620,7 +620,7 @@ int main(void) {
这里为了简短用 fork 创建写进程,没有亲缘关系的进程只要用同一个名字调用 shm_open,就能映射到同一块共享内存。
多个进程也可以将同一个文件映射到它们的地址空间从而实现共享内存。另外 XSI 共享内存(shmget、shmat)不是使用文件,而是使用内存的匿名段。
多个进程也可以将同一个文件映射到它们的地址空间从而实现共享内存。另外 XSI 共享内存(即 System V 共享内存,shmget、shmat)不是使用文件,而是使用内存的匿名段。
### 6. 套接字
@@ -684,6 +684,8 @@ $ java -XX:+PrintFlagsFinal -version | grep -w ThreadStackSize
intx ThreadStackSize = 2040
```
同样启动 1 万个虚拟线程,加 -Xint(只解释执行)时每个约 2.6 KB,加 -Xcomp(执行前先编译)时约 1.0 KB,默认约 2 KB,代码的执行方式会影响卸载时保存的栈帧大小。默认模式下启动 100 万个时平均约 0.7 KB,可能是运行过程中即时编译让保存的栈帧变小了。
把最大堆改为 256 MB 后启动 100 万个虚拟线程:
```text