并发与多处理幻觉#

有一个问题, 我们有一台计算机,它通常只有寥寥几个CPU核心,但是我们希望同时运行数十上百个程序（浏览器、编辑器、音乐播放器……）。如何在少量物理核心上“同时“执行大量程序？

操作系统提出了线程 (Thread)——一个独立的执行上下文。 的概念.

通过在多个线程之间快速切换（每秒钟数百到数千次），操作系统创造了多处理器幻觉 (Illusion of Multiple Processors)：每个程序仿佛独占一个 CPU。

线程的核心机制:线程控制块 (TCB) 与上下文切换#

线程的核心机制在于：暂停时保存状态，恢复时还原状态。

1
typedef struct TCB {
2
    // === 线程标识 ===
3
    tid_t        tcb_tid;          // 线程唯一 ID
4
    char         tcb_name[32];     // 线程名称（调试用）
5

6
    // === 执行状态 ===
7
    thread_state_t tcb_state;      // RUNNING / READY / BLOCKED / ZOMBIE
8
    int          tcb_priority;     // 调度优先级
9

10
    // === CPU 上下文（核心！）===
11
    struct {
12
        uint64_t  pc;              // 程序计数器 (Program Counter)
13
        uint64_t  sp;              // 栈指针 (Stack Pointer)
14
        uint64_t  regs[16];        // 通用寄存器 (General-Purpose Registers)
15
        uint64_t  flags;           // 状态标志寄存器 (EFLAGS / PSTATE)
16
    } tcb_context;
17

18
    // === 栈信息 ===
19
    void        *tcb_stack_base;   // 线程私有栈基址
20
    size_t       tcb_stack_size;   // 栈大小
21

22
    // === 调度信息 ===
23
    uint32_t     tcb_timeslice;    // 剩余时间片 (ticks)
24
    uint64_t     tcb_total_ticks;  // 累计运行时间
25

26
    // === 链接字段 ===
27
    struct TCB  *tcb_next;         // 链表指针（就绪队列）
28
    struct PCB  *tcb_owner;        // 所属进程
29
} TCB;

CPU的架构设计#

目前CPU的架构设计主要分为两种,一种为RISC(精简指令集),另一种为CISC(复杂指令集).

RISC (Reduced Instruction Set Computer，精简指令集计算机)的指令集较为简单,秉承的设计哲学为:一条指令只做一件事情,执行效率高. 代表的架构有: ARM,RISC-V等.对线程的影响：寄存器更多 → TCB 保存的上下文更大 → 上下文切换开销更高；但流水线浅 → 中断响应延迟更可预测

CISC (Complex Instruction Set Computer，复杂指令集计算机)的指令集设计原则为一条指令要做很多件任务, 减少程序代码量,十分复杂. 代表的架构有: x86(Intel, AMD等). 对线程的影响：寄存器更少 → TCB 上下文更小 → 上下文切换更快；但通过微码 (Microcode) 将 CISC 指令拆解为类 RISC 的 μop 执行

线程的形式定义,状态和调度#

线程的定义很简单, 线程是一个独立的执行上下文,由程序计数器 (PC)、寄存器集合 (Registers)、栈指针 (SP) 和私有栈 (Stack) 共同定义。一个线程正在执行时，其状态位于 CPU 的物理寄存器中；被挂起时，其状态保存在 TCB 中。

作为操作系统对于CPU工作单元的抽象,线程的状态机定义了线程在不同状态下的行为和转换.

关于地址空间的定义#

地址空间 (Address Space) 是一个进程可以访问（读/写/执行）的所有内存地址的集合，以及这些地址所关联的状态。

一个典型的地址空间由以下部分组成：

• 代码段 (Code Segment)：存放程序的指令
• 数据段 (Data Segment)：存放程序的全局变量和静态数据
• 堆 (Heap)：动态分配的内存区域
• 栈 (Stack)：函数调用时的局部变量和返回地址

1
高地址
2
┌───────────────┐
3
│ Stack         │
4
│ ↓             │
5
├───────────────┤
6
│               │
7
│   Free Space  │
8
│               │
9
├───────────────┤
10
│ Heap          │
11
│ ↑             │
12
├───────────────┤
13
│ Data          │
14
├───────────────┤
15
│ Code(Text)    │
16
└───────────────┘
17
低地址

地址空间提供了什么能力?

1. 隔离进程,让进程之间互不干扰.

程序创建的进程A和进程B之间井水不犯河水, 它们的地址空间相互独立. Chrome 不能修改VSCode中的内存

2. 提供保护,用户不能够随便访问内核

用户模式就不应该随便访问内核,否则会有普通程序,修改系统程序导致操作系统崩溃.

分页#

在一般讨论的内存管理方案中,要求进程的物理地址空间是连续的. 但是我们需要一种允许进程的物理地址空间不连续的内存管理方案---分页.

分页同时避免了外部碎片和相关的压缩需求,这是困扰连续内存分配的两个问题.

分页的实现#

实现分页的基本方法设计将物理内存分为固定大小的块, 称为帧或页帧,并将逻辑内存也分为同样大小的块,称为页或页面. 当需要执行一个进程的时候,其页从文件系统或备份储备等源处加载到内存的可用帧.

分段与页表的演进#

经典问题: 32位和64位地址空间的CPU区别#

32位和64位的CPU区别可不简单是数字不同,CPU地址空间位数代表着CPU一次能够处理多宽的地址，以及能够寻址多大的虚拟地址空间。

32位 CPU 一次处理 32 位地址，寻址范围为 2^32 字节（约 4GB）, 而 64位 CPU 一次处理 64 位地址，寻址范围为 2^64 字节（约 16EB）

这其中,64位的CPU可以更快的处理完内存映射,而32位则无法一次映射.

在操作系统中,为什么单有线程不够?#

线程只解决了”执行”的抽象，却不提供隔离 (Isolation)。同一地址空间的多个线程共享全部内存——一个线程的越界写入可以悄无声息地破坏另一个线程的数据（“无声的数据损坏”，最可怕的 bug 类型）。进程通过为每个运行程序赋予独立的地址空间，从根本上解决了这一问题。

代价：同一进程内的线程通过共享内存通信极其简单（读/写共享变量），而跨进程通信 (IPC, Inter-Process Communication) 则需要通过 OS 介入的机制（管道、消息队列、共享内存映射、Socket），代价高得多。这是保护与通信之间的根本权衡。

进程的诞生与 PCB#

进程创建（Process Creation）的完整流程其实是在回答：

一个可执行文件（Program）是如何变成一个正在运行的进程（Process）的？

1
#include <stdio.h>
2
#include <unistd.h>
3

4
int main() {
5
    pid_t pid = fork();
6

7
    if (pid == 0) {
8
        printf("Child Process: PID=%d\n", getpid());
9
    } else {
10
        printf("Parent Process: PID=%d\n", getpid());
11
    }
12

13
    return 0;
14
}

1
┌─────────────┐
2
│ Code        │
3
├─────────────┤
4
│ Data        │
5
├─────────────┤
6
│ Heap        │
7
├─────────────┤
8
│ Stack       │
9
└─────────────┘

系统调用 (System Call) 的全链路机制#

系统调用（System Call）的全链路机制，本质是用户态程序访问内核态服务的一条受控通道：

1. 当应用程序（运行在用户态）需要执行文件读写、网络通信或进程管理等特权操作时，会先通过封装好的 API（如 Linux 的 glibc 包装函数）触发一条“系统调用指令”（例如 x86 的 syscall 或 int 0x80）

2. CPU 在执行该指令时会发生一次受控的特权级切换，从用户态（Ring 3）进入内核态（Ring 0），同时保存当前进程的上下文（寄存器、程序计数器、栈信息等），并跳转到操作系统预先定义好的系统调用入口（system call handler）

3. 内核随后根据系统调用号（syscall number）在系统调用表（syscall table）中查找对应的内核函数（如 sys_read、sys_write），执行具体的内核逻辑（可能涉及文件系统、设备驱动、网络栈或调度器），在完成后将结果写回寄存器或用户空间缓冲区

4. 最后内核执行“返回用户态”指令恢复之前保存的上下文，使 CPU 回到原来的用户程序继续执行。整个过程的关键在于：通过硬件支持的特权级切换 + 内核统一入口分发 + syscall table 映射 + 上下文保存与恢复，实现安全隔离下的受控资源访问。