返回专栏
· 19 分钟阅读

进程与线程


一、进程与线程的基本概念

1. 进程(Process)

进程是程序的一次运行实例,是操作系统进行资源管理和隔离的重要抽象。

程序是静态的指令和数据集合,进程则是程序运行时形成的动态实体。

一个进程通常包含:

  • 进程控制块(PCB):操作系统管理进程所需的核心数据结构。
  • 虚拟地址空间:进程可见的内存地址范围。
  • 代码段:程序指令。
  • 数据段:全局变量、静态变量等数据。
  • 堆(Heap):动态内存分配区域。
  • 栈(Stack):函数调用、局部变量等执行上下文。
  • 打开的文件与 I/O 资源:文件描述符、套接字等。
  • 至少一个线程:负责实际执行指令。

进程是资源管理和隔离的容器,但本身并不直接完成指令执行。实际执行由进程中的线程承担。

2. 线程(Thread)

线程是进程内部的执行流,是 CPU 调度的基本单位。

一个进程可以包含一个或多个线程。每个线程拥有独立的执行上下文,但共享所属进程的大部分资源。

线程通常具有:

  • 线程标识符(TID)。
  • 程序计数器(PC)。
  • CPU 寄存器状态。
  • 独立的线程栈。
  • 线程局部存储(TLS)。
  • 调度状态和优先级等信息。

线程执行时,CPU 需要保存和恢复线程的寄存器、程序计数器等上下文,以便在不同线程之间切换。

3. 核心区别

比较维度 进程 线程
基本定位 资源管理与隔离单位 执行与调度单位
资源拥有 拥有独立进程资源 共享进程资源
地址空间 通常独立 同进程线程共享
栈空间 进程中的线程各自拥有 每个线程独立
寄存器状态 由线程执行上下文承载 每个线程独立
创建开销 通常较大 通常较小
切换开销 通常较大 通常较小
通信方式 IPC 机制 共享内存、同步原语
故障影响 通常具有进程隔离边界 可能影响整个进程
并发执行 通过进程内线程实现 直接参与调度

需要注意:进程切换和线程切换的成本并不是固定值。是否切换地址空间、是否发生 TLB 刷新、缓存命中情况、内核实现等因素都会影响实际开销。


二、进程的内部结构

1. 进程控制块(PCB)

PCB(Process Control Block)是操作系统用于描述和管理进程的数据结构。

常见信息包括:

信息类别 主要内容
标识信息 PID、父进程 PID、用户 ID
处理器状态 程序计数器、寄存器状态
调度信息 进程状态、优先级、调度参数
内存信息 页表、地址空间描述信息
文件信息 打开的文件、文件描述符
资源信息 已分配资源、资源使用统计
关系信息 父子进程、进程组、会话

PCB 是概念层面的操作系统管理结构。Linux 内核中,进程和线程都通过 task_struct 等内核结构进行管理,并非所有系统都采用完全相同的数据结构。

2. 进程的内存布局

一个典型进程的虚拟地址空间可以抽象为:

高地址
┌──────────────────────────┐
│        内核空间           │
├──────────────────────────┤
│        用户栈             │
│        Stack              │
│        ↓                  │
├──────────────────────────┤
│                          │
│        内存映射区域       │
│   共享库、文件映射等      │
│                          │
├──────────────────────────┤
│        ↑                  │
│        堆                 │
│        Heap               │
├──────────────────────────┤
│        BSS 段             │
│   未初始化的全局变量      │
├──────────────────────────┤
│        Data 段            │
│   已初始化的全局变量      │
├──────────────────────────┤
│        Text 段            │
│        程序代码           │
└──────────────────────────┘
低地址

这是常见的进程虚拟地址空间示意,并不代表所有架构和操作系统都采用相同的地址排列。

需要区分:

  • 虚拟地址空间:进程看到的逻辑地址范围。
  • 物理内存:实际的 RAM 页面。
  • 页表:负责虚拟地址到物理地址的映射。
  • 内存映射区域:用于映射共享库、文件、匿名内存等。

进程拥有独立的虚拟地址空间,不代表每个进程的全部物理内存都完全独立。多个进程可以通过共享内存、共享库映射等方式共享物理页面。

3. 进程资源的所有权

进程通常管理以下资源:

  1. 虚拟地址空间。
  2. 文件描述符表。
  3. 信号处理配置。
  4. 工作目录和根目录等文件系统上下文。
  5. 用户身份和权限信息。
  6. 进程级别的资源限制。

具体资源的共享与继承规则取决于操作系统和创建进程时使用的机制。


三、线程的内部结构

1. 线程独立拥有的资源

同一进程内的线程共享进程的大部分资源,但每个线程需要独立维护执行状态。

线程私有内容 作用
程序计数器 记录下一条待执行指令
CPU 寄存器 保存当前执行状态
线程栈 保存函数调用帧、局部变量等
线程 ID 唯一标识线程
线程局部存储 保存线程私有数据
调度状态 描述线程当前运行状态

线程栈是线程独立执行所必需的。多个线程如果共用同一个调用栈,就无法正确维护各自的函数调用关系和局部执行状态。

2. 线程共享的资源

同一进程中的线程通常共享:

  • 程序代码。
  • 全局变量和静态变量。
  • 堆内存。
  • 内存映射区域。
  • 文件描述符表。
  • 进程级别的资源和属性。

例如:

#include <pthread.h>
#include <stdio.h>

int counter = 0;

void* worker(void* arg) {
    counter++;
    return NULL;
}

int main() {
    pthread_t t1, t2;

    pthread_create(&t1, NULL, worker, NULL);
    pthread_create(&t2, NULL, worker, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    printf("%d\n", counter);
    return 0;
}

这里两个线程共享全局变量 counter。

但该程序存在数据竞争:counter++ 并不是原子操作,两个线程可能同时读取并修改该变量,导致更新丢失。

正确实现需要使用互斥锁或原子变量。

3. 进程与线程的资源关系

flowchart TB
    P["进程 Process"]
    P --> M["共享地址空间"]
    P --> F["共享文件描述符等进程资源"]
    P --> T1["线程 T1"]
    P --> T2["线程 T2"]
    P --> T3["线程 T3"]

    T1 --> S1["独立栈"]
    T1 --> R1["独立寄存器与程序计数器"]
    T2 --> S2["独立栈"]
    T2 --> R2["独立寄存器与程序计数器"]
    T3 --> S3["独立栈"]
    T3 --> R3["独立寄存器与程序计数器"]

    style P fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style M fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style T1 fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style T2 fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style T3 fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style S1 fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style S2 fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style S3 fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style R1 fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style R2 fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style R3 fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这也是多线程编程最重要的结构特征:共享资源提升了协作效率,但同时引入了同步和数据一致性问题。


四、进程的生命周期与状态转换

1. 进程的基本状态

操作系统通常使用状态机描述进程的生命周期。

常见状态包括:

状态 含义
新建(New) 正在创建进程
就绪(Ready) 已具备运行条件,等待 CPU
运行(Running) 正在 CPU 上执行
阻塞(Blocked) 等待 I/O 或某个事件
终止(Terminated) 执行结束或被终止

部分操作系统还存在挂起就绪、挂起阻塞等状态。

2. 状态转换机制

flowchart TD
    A["新建 New"] --> B["就绪 Ready"]
    B --> C["运行 Running"]
    C --> D["阻塞 Blocked"]
    D --> B
    C --> E["终止 Terminated"]
    C --> B

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

主要转换原因:

  • 新建到就绪:操作系统完成进程创建和必要资源初始化。
  • 就绪到运行:调度器选择该进程中的可运行线程执行。
  • 运行到就绪:时间片用完、被抢占或主动让出 CPU。
  • 运行到阻塞:等待磁盘 I/O、网络 I/O、锁或其他事件。
  • 阻塞到就绪:等待的事件完成。
  • 运行到终止:程序正常退出或被终止。

严格来说,现代操作系统的调度对象通常是线程,而不是抽象的进程状态。一个多线程进程可能同时包含运行、就绪和阻塞状态不同的线程。

3. 进程状态与线程状态的区别

对于多线程进程:

  • 进程整体可能仍然存在。
  • 某个线程可能已经终止。
  • 另一个线程可能正在运行。
  • 还有线程可能因为锁竞争而阻塞。

因此,不能简单地认为一个进程在任何时刻只有一个执行状态。


五、进程创建与终止

1. 进程创建

以 Linux/Unix 系统为例,常见的进程创建方式包括 fork() 和 exec()。

  • fork():创建一个新的子进程。
  • exec():用新的程序映像替换当前进程的程序映像。
  • wait() / waitpid():父进程等待子进程状态变化并回收其退出状态。

典型执行过程:

flowchart TD
    A["父进程运行"] --> B["调用 fork()"]
    B --> C["创建子进程"]
    C --> D["父进程继续执行"]
    C --> E["子进程继续执行"]
    E --> F["调用 exec()"]
    F --> G["加载新程序映像"]
    G --> H["执行新程序"]
    H --> I["子进程退出"]
    I --> J["父进程调用 wait() 回收状态"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

2. Copy-on-Write(写时复制)

fork() 创建子进程时,通常不会立即复制父进程的全部物理内存。

现代 Linux 等系统通常使用 Copy-on-Write(COW)机制:

  1. 父子进程最初共享相同的物理内存页面。
  2. 页面被标记为写时复制。
  3. 任一进程尝试写入共享页面时,触发缺页异常。
  4. 内核为写入方分配新的物理页面。
  5. 将原页面内容复制到新页面。
  6. 更新对应页表映射,完成写入。
flowchart TD
    A["fork() 创建子进程"] --> B["父子进程共享物理页面"]
    B --> C["页面标记为 COW"]
    C --> D["某一进程尝试写入"]
    D --> E["触发缺页异常"]
    E --> F["分配新的物理页面"]
    F --> G["复制原页面内容"]
    G --> H["更新页表映射"]
    H --> I["进程独立修改页面"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

COW 可以减少进程创建时的内存复制开销,尤其适合创建后立即执行 exec() 的场景。

需要注意:

  • COW 并不意味着完全没有内存开销。
  • 创建子进程仍然需要建立相应的内核管理结构和页表等数据。
  • 写入共享页面时可能触发实际复制。
  • fork() 后父子进程拥有逻辑上独立的地址空间。

3. 僵尸进程与孤儿进程

僵尸进程(Zombie Process)

子进程已经退出,但父进程尚未通过 wait() 或相关接口回收其退出状态。

此时,子进程的大部分资源已经释放,但内核仍保留必要的退出信息和进程标识,以便父进程查询。

孤儿进程(Orphan Process)

父进程先于子进程退出,子进程仍在运行。

在 Linux 中,孤儿进程通常会被重新托管给适当的系统级收养进程或配置的子收割进程。

对比 僵尸进程 孤儿进程
子进程是否运行 已退出 仍在运行
主要问题 退出状态未回收 原父进程已经退出
资源占用 保留少量内核信息 正常占用运行资源
处理方式 父进程回收退出状态 由新的父进程管理

六、线程的生命周期与管理

1. 线程的基本状态

线程常见状态包括:

  • 新建(New)
  • 就绪(Runnable / Ready)
  • 运行(Running)
  • 阻塞(Blocked)
  • 等待(Waiting)
  • 计时等待(Timed Waiting)
  • 终止(Terminated)

不同语言和运行时对线程状态的定义并不完全一致。

例如 Java 的 Thread.State 包含 NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING 和 TERMINATED。其中 RUNNABLE 在 Java 中包含可运行和正在运行的状态。

2. 线程状态转换

flowchart TD
    A["新建 New"] --> B["就绪 Runnable"]
    B --> C["运行 Running"]
    C --> D["阻塞 Blocked"]
    C --> E["等待 Waiting"]
    C --> F["计时等待 Timed Waiting"]
    D --> B
    E --> B
    F --> B
    C --> G["终止 Terminated"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

3. 线程创建与销毁

以 POSIX 线程为例:

#include <pthread.h>
#include <stdio.h>

void* worker(void* arg) {
    printf("Worker thread running\n");
    return NULL;
}

int main() {
    pthread_t tid;

    pthread_create(&tid, NULL, worker, NULL);

    pthread_join(tid, NULL);

    printf("Main thread finished\n");
    return 0;
}

关键接口:

接口 作用
pthread_create() 创建线程
pthread_join() 等待指定线程终止并回收其可连接资源
pthread_detach() 将线程设置为分离状态
pthread_exit() 终止当前线程
pthread_self() 获取当前线程 ID

线程终止并不意味着整个进程终止。

只有当进程中的所有线程都结束,或者进程被显式终止等条件满足时,进程才会结束。


七、进程与线程的创建成本

1. 进程创建成本

创建进程通常涉及:

  • 分配进程管理结构。
  • 建立新的虚拟地址空间。
  • 创建或复制页表相关结构。
  • 处理文件描述符和其他资源的继承。
  • 初始化调度和安全相关信息。

使用 COW 后,通常不需要立即复制全部物理内存,但仍然存在内核管理和地址空间初始化成本。

2. 线程创建成本

创建线程通常需要:

  • 分配线程控制结构。
  • 分配线程栈。
  • 初始化寄存器和执行上下文。
  • 初始化线程局部存储。
  • 将线程加入调度体系。

同一进程内创建线程通常不需要创建新的完整地址空间,因此开销一般小于创建独立进程。

3. 线程并不一定总是更高效

线程虽然轻量,但大量线程会产生额外成本:

  • 线程栈占用内存。
  • 调度和上下文切换开销。
  • 锁竞争和同步成本。
  • CPU 缓存失效。
  • 线程管理和资源回收成本。

如果任务数量远大于 CPU 核心数量,盲目创建大量线程可能降低系统吞吐量。


八、进程间通信(IPC)

不同进程拥有相互隔离的虚拟地址空间,一个进程不能直接访问另一个进程的普通私有内存。

进程之间需要通过 IPC(Inter-Process Communication)机制交换数据和协调行为。

1. 常见 IPC 机制

IPC 机制 基本原理 典型用途
管道(Pipe) 内核维护字节流缓冲区 父子进程通信
命名管道(FIFO) 通过文件系统名称建立通信通道 无亲缘关系进程通信
消息队列 内核维护消息结构 异步消息交换
共享内存 多进程映射同一物理内存区域 大数据量、高性能通信
信号(Signal) 发送异步事件通知 事件通知、进程控制
套接字(Socket) 通过通信端点交换数据 本机或网络通信
信号量(Semaphore) 维护计数状态进行同步 资源协调

2. 共享内存

共享内存是效率较高的 IPC 方式。

多个进程将同一物理内存区域映射到各自的虚拟地址空间,从而实现数据共享。

flowchart TB
    A["进程 A"] --> B["进程 A 虚拟地址空间"]
    C["进程 B"] --> D["进程 B 虚拟地址空间"]
    B --> E["共享物理内存区域"]
    D --> E
    E --> F["共享数据"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

共享内存的优势:

  • 避免频繁的数据复制。
  • 适合传输大块数据。
  • 数据访问速度通常较快。

主要问题:

  • 需要额外的同步机制。
  • 必须处理并发读写。
  • 需要管理共享内存的生命周期。
  • 不同进程可能将共享区域映射到不同的虚拟地址。

共享内存只解决数据共享问题,不自动解决数据一致性问题。通常需要配合进程间互斥锁、信号量或其他同步原语。


九、线程间通信与同步

1. 线程间通信

同一进程中的线程共享地址空间,因此可以直接通过共享变量、堆对象等方式传递数据。

常见方式:

  • 共享变量。
  • 共享对象。
  • 消息队列。
  • 条件变量。
  • 线程安全队列。
  • 原子变量。

线程之间共享数据非常方便,但也容易出现竞态条件。

2. 线程同步机制

同步机制 作用 典型场景
互斥锁(Mutex) 保证临界区互斥访问 共享数据保护
读写锁(RWLock) 允许多读、单写 读多写少
信号量(Semaphore) 控制并发访问数量 限制资源并发数
条件变量(Condition Variable) 等待特定条件成立 生产者消费者
自旋锁(Spinlock) 通过循环等待获取锁 极短临界区
原子操作(Atomic) 提供不可分割的操作 计数器、状态标记

3. 竞态条件(Race Condition)

竞态条件指程序结果依赖于多个执行流的具体交错顺序。

例如:

counter++;

通常可以抽象为三个步骤:

  1. 读取 counter。
  2. 执行加法。
  3. 将结果写回 counter。

两个线程可能出现如下交错:

sequenceDiagram
    participant T1 as 线程 T1
    participant M as 共享变量 counter
    participant T2 as 线程 T2

    T1->>M: 读取 0
    T2->>M: 读取 0
    T1->>T1: 计算 0 + 1
    T2->>T2: 计算 0 + 1
    T1->>M: 写入 1
    T2->>M: 写入 1
    Note over M: 最终结果为 1,而不是 2

解决方式包括: