并发基础：重新理解多线程世界

并发基础：重新理解多线程世界

想象一下这个场景：你在厨房里同时做三件事——煮咖啡、洗碗、听音乐。这三件事看似同时进行，但实际上你在不断切换注意力：搅拌一下咖啡，看一眼洗碗的进度，顺着旋律哼唱两句。你的大脑在三个任务之间快速切换，每个任务轮流获得你的"时间片"。这种看似同时处理多个任务的能力，在计算机世界中有一个专门的名字——并发（Concurrency）。

然而，计算机的并发与人类的并发有着本质的不同。人类可以自然地处理中断和切换，而计算机的并发则涉及更深层次的硬件原理、操作系统机制和软件设计。本章我们将深入探讨这些底层概念，为后续理解高并发系统奠定坚实的理论基础。

进程：资源分配的最小单位

在深入并发之前，我们需要理解计算机系统中一个核心概念——进程（Process）。

什么是进程

简单来说，进程是一个正在运行的程序的实例。当你在终端输入 `python hello.py` 并按下回车键时，操作系统会创建一个新的进程来执行这个Python程序。这个进程不仅仅包含程序的代码（指令序列），还包含运行所需的一切资源：内存空间、打开的文件描述符、网络连接、信号处理器等。

从操作系统的角度来看，进程是资源分配的最小单位。当你请求创建一个进程时，操作系统会为它分配独立的内存空间、建立文件句柄表、设置进程控制块（PCB, Process Control Block）等。进程与进程之间是相互隔离的，这种隔离保证了系统的稳定性和安全性——一个进程的崩溃不会直接影响另一个进程的运行。

我们可以把进程想象成一个独立的工厂。每个工厂有自己的厂房（内存空间）、生产线（CPU执行流）、仓库（资源）。工厂之间不能随意访问对方的资源，这种隔离机制是现代操作系统安全模型的基础。

进程的组成结构

一个典型的进程包含以下几个核心部分：

程序代码（Text Section）：存储可执行指令的内存区域。当我们编译一个程序时，编译器生成的机器指令就存储在这里。这部分通常是只读的，以防止进程意外修改自己的代码。

进程控制块（PCB）：这是操作系统为每个进程维护的一个内核数据结构，包含了进程运行所需的所有状态信息。PCB中记录了诸如进程ID（PID）、程序计数器（PC）、寄存器值、调度信息、内存管理信息、打开的文件列表、资源限制等关键数据。当进程被切换出CPU时，CPU的所有状态信息都会被保存到该进程的PCB中，以便下次恢复执行。

堆（Heap）：用于动态内存分配的区域。当程序使用 `malloc()` 或 `new` 分配内存时，这块内存就从堆中获得。堆是被所有线程共享的，这也是多线程编程中需要特别注意内存同步的原因之一。

栈（Stack）：用于存储函数调用、局部变量和返回地址的区域。在早期的单进程单线程模型中，每个进程只有一个栈。但在多线程模型中，每个线程都有自己独立的栈，这使得线程可以独立地执行函数调用而不互相干扰。

```c // 进程的典型内存布局 +------------------+ 高地址 | 内核空间 | +------------------+ | 栈 | ← 函数调用、局部变量（向下增长） +------------------+ | ↓ | | (空闲区) | | ↑ | +------------------+ | 堆 | ← 动态分配（向上增长） +------------------+ | 未初始化数据 | ← BSS段 +------------------+ | 已初始化数据 | ← Data段 +------------------+ | 程序代码 | ← Text段 +------------------+ 低地址 ```

进程的创建与销毁

在Unix/Linux系统中，进程的创建主要通过 `fork()` 系统调用实现。这个系统调用非常独特——它会创建一个当前进程的副本。子进程获得父进程地址空间的完整拷贝，包括打开的文件描述符、内存映射、寄存器状态等。随后，子进程通常会调用 `exec()` 系列函数来用新的程序替换自己的地址空间。

```c #include <stdio.h> #include <unistd.h> #include <sys/wait.h>

int main() { pid_t pid = fork();

if (pid < 0) { perror("fork failed"); return 1; } else if (pid == 0) { // 子进程 printf("我是子进程，PID: %d\n", getpid()); execlp("ls", "ls", "-la", NULL); // execlp成功后，不会执行到这里 perror("execlp failed"); } else { // 父进程 printf("我是父进程，PID: %d，子进程PID: %d\n", getpid(), pid); int status; waitpid(pid, &status, 0); // 等待子进程结束 printf("子进程已退出，状态码: %d\n", WEXITSTATUS(status)); }

return 0; } ```

这种"先fork再exec"的模式是Unix设计哲学的体现，它将进程的创建和程序的加载解耦，提供了极大的灵活性。

线程：CPU调度的最小单位

如果说进程是一个独立的工厂，那么线程就是工厂里的一条生产线。同一工厂（进程）下的不同生产线（线程）共享厂房的公共资源，但各自有独立的生产流程。

线程的本质

线程（Thread），有时被称为轻量级进程（Light-Weight Process），是CPU调度的最小单位。一个进程至少包含一个线程，这个线程被称为主线程。在一个进程内，可以创建多个线程来并发执行不同的任务。这些线程共享进程的地址空间、打开的文件、信号处理、堆等资源，但每个线程拥有自己的栈和寄存器状态。

这种共享与独立的平衡使得线程成为理想的并发执行单位。线程间的通信（IPC）远比进程间通信简单，因为它们可以直接读写共享内存。同时，由于线程共享大部分资源，创建和销毁线程的开销远小于进程。

线程与进程的关键区别

让我们通过一个表格来清晰理解进程与线程的区别：

| 维度 | 进程 | 线程 | |------|------|------| | 资源拥有 | 拥有独立的地址空间 | 共享进程的地址空间 | | 创建开销 | 大（需要复制大量资源） | 小（共享资源，只需分配栈和寄存器） | | 通信方式 | 管道、消息队列、共享内存、Socket等 | 直接读写共享内存 | | 隔离性 | 强隔离，一个崩溃不影响另一个 | 弱隔离，一个崩溃可能导致整个进程崩溃 | | 调度 | 由内核管理 | 由内核管理（内核线程）或用户空间管理（用户线程） | | 同步开销 | 需要跨进程同步机制 | 只需线程间同步（互斥锁、条件变量等） |

线程的组成

每个线程都有自己独立的：

线程ID（TID）：在线程所属进程内的唯一标识符

寄存器上下文：包括程序计数器（PC）、栈指针（SP）、通用寄存器等。这些信息保存在线程控制块（TCB）中，用于上下文切换

栈：用于函数调用、局部变量存储。虽然栈本身是线程私有的，但如果多个线程调用同一个函数，它们各自的局部变量不会相互干扰

调度属性：如优先级、调度策略等

线程共享：

代码段：所有线程执行相同的指令序列

全局/堆数据：所有线程可以访问相同的全局变量和动态分配的内存

文件描述符表：所有线程共享进程打开的文件

```c // 使用POSIX线程库创建线程 #include <pthread.h> #include <stdio.h> #include <unistd.h>

void* thread_function(void* arg) { int id = *(int*)arg; for (int i = 0; i < 5; i++) { printf("线程 %d: 第 %d 次执行\n", id, i + 1); usleep(100000); // 100ms } return NULL; }

int main() { pthread_t threads[3]; int ids[3] = {1, 2, 3};

// 创建三个线程 for (int i = 0; i < 3; i++) { if (pthread_create(&threads[i], NULL, thread_function, &ids[i]) != 0) { perror("pthread_create failed"); return 1; } }

// 等待所有线程结束 for (int i = 0; i < 3; i++) { pthread_join(threads[i], NULL); }

printf("所有线程执行完毕\n"); return 0; } ```

为什么现代系统选择线程而非进程

理解了进程和线程的概念后，一个自然的问题是：既然线程能做进程能做的所有事情，而且开销更小，为什么不直接用线程代替进程呢？

答案在于隔离与共享的权衡。

进程提供了强隔离性，这在大规模分布式系统、多用户系统中是必需的。比如，Web服务器通常为每个用户请求创建一个独立的进程，这样即使某个请求处理出错导致进程崩溃，也不会影响其他用户。但进程的创建和切换开销确实更大。

线程则是对同一地址空间内并发的优化。当多个任务需要频繁通信、需要共享大量数据时，线程比进程高效得多。比如，一个图形渲染程序可能创建多个线程分别处理顶点着色、光栅化、纹理映射等任务，它们需要共享几何数据、纹理数据等，用线程比用进程方便得多。

现代操作系统通常同时支持进程和线程，并根据具体场景选择使用。在Web服务器中，一个常见的模式是：主进程监听端口，接受连接后创建线程或使用线程池来处理请求。这样既利用了线程的高效性，又保持了进程级别的容错能力。

时间片轮转：CPU的"分时复用"魔法

无论是进程还是线程，它们要真正在CPU上执行，都需要操作系统的调度。而理解调度机制的关键，是理解时间片（Time Slice）的概念。

分时系统的诞生

在计算机发展的早期，CPU非常昂贵且速度很快，而用户交互设备（如终端、打印机）却很慢。为了提高CPU利用率，操作系统引入了分时（Time-Sharing）的概念——让多个用户或多个任务"同时"使用CPU。

这种"同时"实际上是虚拟的。操作系统将CPU时间划分为极小的片段，每个片段称为一个时间片（通常从几毫秒到几十毫秒不等），然后快速地在不同任务之间切换。由于切换速度极快，用户感觉不到中断，仿佛CPU真的在同时处理多个任务。这就是并发（Concurrency）的物理基础。

上下文切换

当CPU从一个任务切换到另一个任务时，需要完成一个关键操作——上下文切换（Context Switch）。上下文切换保存当前任务的执行状态，并恢复另一个任务的执行状态，使得CPU能够从断点处继续执行。

上下文切换的具体步骤：

第一步：保存上下文。当一个进程或线程被从CPU上换下时，操作系统需要保存它的完整状态。这包括：程序计数器的值（下一条指令的地址）、所有寄存器的值、栈指针、内存管理信息等。这些数据被保存到该任务的内核控制块（PCB或TCB）中。

第二步：更新调度数据结构。操作系统需要更新一系列数据结构，包括：任务状态（从运行变为就绪）、任务队列位置、CPU使用统计等。

第三步：选择下一个任务。调度器根据调度算法（如时间片轮转、优先级调度等）选择一个合适的任务来执行。

第四步：恢复上下文。选中的任务的相关状态从其控制块中恢复，包括寄存器值、程序计数器、栈指针等。

第五步：跳转到新任务。CPU的程序计数器被设置为新任务的起始地址（或断点地址），新任务开始执行。

整个上下文切换过程在现代x86-64处理器上通常需要几百个CPU周期，加上现代CPU的缓存失效惩罚，实际耗时可能达到1-5微秒。这个时间看似很短，但累积效应不可忽视——如果每秒进行10000次上下文切换，就可能消耗10-50毫秒的CPU时间，占总运行时间的1-5%。

```mermaid graph TD A[任务A正在运行] --> B[时钟中断到达] B --> C[保存任务A的上下文<br/>寄存器、PC、栈指针等] C --> D[更新任务A的PCB<br/>状态改为就绪] D --> E[调度器选择下一个任务] E --> F[恢复任务B的上下文<br/>从任务B的PCB加载] F --> G[更新任务B的PCB<br/>状态改为运行] G --> H[跳转到任务B的PC处执行] H --> I[任务B开始运行]

style A fill:#90EE90 style I fill:#90EE90 style C fill:#FFB6C1 style F fill:#FFB6C1 ```

时间片轮转调度

时间片轮转（Round-Robin, RR）是最基本、最直观的调度算法。其核心思想很简单：操作系统为每个就绪队列中的任务分配固定长度的时间片，当一个任务用完时间片后，就被放到队列末尾，CPU分配给下一个任务。

时间片的长度是一个关键的调参。太短会导致频繁的上下文切换，开销增大；太长会降低系统的响应性，用户会感觉到"卡顿"。现代操作系统通常将时间片设置为5-100毫秒，具体值取决于系统负载、硬件特性等因素。

考虑一个具体场景：三个进程A、B、C争夺CPU。如果采用时间片轮转，时间片为10毫秒，执行顺序可能是这样的：

``` 时间: 0-10ms → 进程A执行 时间: 10-20ms → 进程B执行 时间: 20-30ms → 进程C执行 时间: 30-40ms → 进程A继续（第二个时间片） 时间: 40-50ms → 进程B继续 时间: 50-60ms → 进程C继续 ... ```

在Linux系统中，我们可以使用 `nice` 命令和 `chrt` 工具来观察和调整进程的调度策略：

```bash

查看进程119的调度信息

chrt -p 119

将进程设置为SCHED_RR策略，优先级10

chrt -r -p 10 119

查看进程的调度策略

ps -eo pid,comm,policy,rt_priority,cmd ```

抢占式调度

现代操作系统几乎都采用抢占式（Preemptive）调度。这意味着即使当前任务正在执行，操作系统也可以强制中断它，切换到其他任务。这种强制中断主要由以下事件触发：

时间片用完：当前任务已连续运行一个完整的时间片

高优先级任务就绪：出现了一个更重要的任务需要处理

I/O中断：等待I/O的任务完成，等待中的任务变为就绪

显式系统调用：任务主动调用 `sched_yield()` 放弃CPU

实时信号：硬件或软件产生的信号中断当前执行

抢占式调度的优势在于保证了公平性和响应性。任何任务都不能长时间霸占CPU，交互式任务（如用户输入）可以得到及时响应。但这也带来了一些复杂性：开发者需要考虑任务随时可能被挂起的可能性，这在多线程编程中尤为重要。

用户态与内核态：权限的边界

在深入理解操作系统的工作原理时，用户态（User Mode）和内核态（Kernel Mode）是两个绕不开的概念。这两种运行状态代表了CPU执行的两种不同的权限级别，也决定了程序能做什么、不能做什么。

为什么需要两种运行状态

设想一个没有特权分离的世界：所有程序都可以直接访问硬件，可以任意读写内存，可以控制系统的一切功能。这会带来灾难性的后果——一个程序出错就可能摧毁整个系统，一个恶意程序可以为所欲为。

为了解决这个问题，现代CPU提供了特权级别（Privilege Level）的概念。x86架构提供4个特权级别（Ring 0到Ring 3），Linux只使用了Ring 0（最高特权，供内核使用）和Ring 3（最低特权，供用户程序使用）。

内核态运行在最高特权级别，可以执行特权指令（如修改CPU状态、访问任意物理内存、操作I/O设备），可以访问全部硬件资源。

用户态运行在最低特权级别，不能执行特权指令，不能直接访问硬件，必须通过系统调用请求内核帮忙。

这种设计确保了系统的安全性和稳定性。即使你的程序有bug或被恶意利用，它也无法直接伤害系统——它对硬件的访问被限制在用户态，所有危险操作必须经过内核的审核。

系统调用：用户与内核的桥梁

用户态程序需要使用内核服务时，必须通过系统调用（System Call）接口。系统调用是从用户态进入内核态的唯一合法通道。每一个系统调用都对应内核提供的一个特定服务。

常见的系统调用包括：

```c // 文件操作 int fd = open("/path/to/file", O_RDONLY); // 打开文件 ssize_t n = read(fd, buffer, count); // 读取数据 ssize_t n = write(fd, buffer, count); // 写入数据 int result = close(fd); // 关闭文件

// 进程管理 pid_t pid = fork();