目录

• 概念与区别

• 进程

• 线程

• 进程 VS 线程

• 协程

• 协程 VS 线程

• 一个进程可创建的线程数量

• 进程和线程的地址空间

• 状态管理与调度

• 进程状态

• 调度算法

• CFS 调度器（Linux）

• 进程终止方式

• 特殊进程

• 僵尸进程（Zombie Process）

• 孤儿进程（Orphan Process）

• 切换与上下文

• 进程的切换过程

• 调度 vs 切换

• 线程的切换过程

• 上下文信息

• 进程 vs 线程切换的区别

• 通信（IPC）方式

• 进程间通信方式

• 线程间通信方式

• 总结对比

• 进程同步

• 临界资源

• 同步遵循的准则

• 实现临界区互斥的基本方法

• 基本内容

• 常见锁

• 锁的优缺点

• 悲观锁 vs 乐观锁

• 死锁

• 概念

• 死锁的四个必要条件（同时满足才可能发生死锁）

• 死锁的处理策略

进程与线程

概念与区别

进程

为了更好的描述和控制程序的并发，实现操作系统的并发性和共享性，引入了进程的概念，为每一个进程分配一个专门的数据结构：进程控制块PCB(常驻内存)，保存运行期间进程的数据，PCB 是进程存在的唯一标志。

进程是操作系统中进行资源分配和调度的最小单位， 是正在运行的程序的实例。每个进程都有自己独立的地址空间、数据栈以及其他用于跟踪进程执行的辅助数据（如文件描述符、寄存器状态等）。

线程

线程是“轻量级进程”，它是基本的CPU执行单元，也是程序执行流的最小单元，由线程ID、程序寄存器、寄存器集合和堆栈组成（即 CPU 调度的基本单元）。线程控制块(Thread Control Block, TCB)：保存运行期间线程的数据，TCB 是线程存在的唯一标志。

线程是 CPU 调度(程序执行)的最小单位，是进程中的一个执行流。一个进程可以包含多个线程，它们共享该进程的地址空间、文件描述符、堆等资源，但每个线程有独立的栈空间和寄存器状态。

进程 VS 线程

引入线程是为了提高程序的并发性能。相较于进程，线程更加轻量，切换开销更低，适合处理高并发、高频率的任务，如 Web 服务、爬虫、图像处理等。他们的区别如下：

进程和线程的关系

1. 一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
2. 资源分配给进程，同一进程的所有线程共享该进程的所有资源。
3. 线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
4. 处理机分给线程，即真正在处理机上运行的是线程。
5. 线程是进程内的一个执行单元，也是进程内的可调度实体。

线程与进程的区别

• 调度： 进程是资源分配和调度的一个独立单元；而线程是 CPU 调度的基本单元。

• 并发性： 不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行。线程并发执行过程中要进行同步和互斥，因为它们共享同一进程的所有资源。

• 拥有资源： 进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。并且线程共享整个进程的资源（寄存器、堆栈、上下文）。

• 系统开销： 线程是轻量级的进程，它的创建和销毁所需要的时间比进程小很多，所以进程在切换和创建销毁时，耗费的资源较大，系统开销较大。

• 健全性： 进程有独立的地址空间，进程崩溃后，在保护模式下不会对其他的进程产生影响；线程有自己的堆栈和局部变量，但没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮。

• 创建和销毁： 进程的创建调用 fork 或者 vfork，而线程的创建调用 pthread_create；进程结束后它拥有的所有线程都将销毁，而线程的结束不会影响同个进程中的其他线程的结束。

协程

协程是一种用户态的轻量级线程，是由用户控制的执行单元，拥有独立的执行上下文和栈。它的调度和上下文切换不依赖操作系统内核，而是由程序显式控制切换，可以在函数中间挂起和恢复执行，非常适合处理 I/O 密集型任务。

协程 VS 线程

协程的切换完全在用户态完成，性能远优于线程，非常适合大量 I/O 场景（如网络请求、数据库操作），可以极大地减少上下文切换开销。他们的主要区别如下：

• 协程本身不具备并行能力，但可以通过线程调度多个协程并发运行；
• 线程的调度是由内核完成，涉及从用户态到内核态的切换

一个进程可创建的线程数量

理论上，线程数量受限于操作系统和硬件资源（如内存）。Linux 中，线程本质上是轻量级进程，一个进程可以创建的线程数没有固定上限，但在 Linux 系统中，一般受限于：

• 每个线程的栈空间大小（默认 8MB）
• 系统虚拟内存总量
• 操作系统配置（如 ulimit）
• 实际上通常能创建的线程数在 几千到几万个之间。

进程和线程的地址空间

关于 进程和线程的地址空间，我们可以从操作系统的资源隔离和共享机制来理解它们的区别：

进程的地址空间

每个进程都有独立的地址空间，包括以下几部分：

不同进程之间的地址空间互不影响，隔离性强，进程间通信（IPC） 需要特殊机制（管道、共享内存等）。

线程的地址空间

线程是进程中的“执行单元”，共享进程的地址空间，但每个线程有自己独立的一小块空间：

总结对比表

每个进程拥有完整独立的地址空间，而线程是进程内的执行单元，共享进程的地址空间但拥有自己的栈和线程私有数据（TLS）。线程之间共享内存，因此通信成本低，但需注意同步与线程安全问题。

状态管理与调度

进程状态

操作系统中的进程通常具有以下几种状态：

• 就绪（Ready）：进程已经获得除 CPU 之外的所有资源，等待 CPU 分配；
• 运行（Running）：进程正在使用 CPU 执行；
• 阻塞（Blocked / Waiting）：进程正在等待某个事件（如 I/O）完成，无法继续执行；
• 新建（New）：进程正在创建中；
• 终止（Terminated / Exit）：进程执行完毕或被中止；
• （有些系统还有：挂起状态，比如“就绪挂起”、“阻塞挂起”，用于内存调度）

进程在操作系统中会在不同状态之间转换，常见状态包括就绪、运行、阻塞三种，状态转移机制如下：

• 运行态 → 阻塞态：进程因等待 I/O 或锁等资源主动放弃 CPU（主动行为）；
• 阻塞态 → 就绪态：等待的资源就绪，操作系统唤醒进程（被动行为）；
• 运行态 → 就绪态：时间片用完或被调度器抢占，进程让出 CPU（被动行为）；
• 就绪态 → 运行态：操作系统调度器分配 CPU 给该进程（被动行为）。

调度算法

调度分级

发生频率比较：高级调度 < 中级调度 < 低级调度

调度方式

常见调度算法

操作系统使用调度算法决定哪个进程/线程优先获得 CPU 时间。常见算法如下：

CFS 调度器（Linux）

CFS（Completely Fair Scheduler）是 Linux 从 2.6.23 版本引入的默认进程调度器，核心目标是实现“尽可能公平”的调度：

• 每个进程维护一个“虚拟运行时间（vruntime）”，运行时间越多，优先级就越低；
• 所有就绪进程按 vruntime 排序，使用红黑树（RBTree）存储，红黑树最左侧节点拥有最高调度优先级；
• 支持进程权重（如 nice 值），可实现公平但带权的调度。

CFS 支持平衡交互性与吞吐量，是目前 Linux 系统通用场景下的主力调度器。

进程终止方式

操作系统中，进程终止主要有以下几种方式：

• 正常终止（Normal exit）：进程主动调用 exit() 或返回主函数，正常结束；
• 错误终止（Error exit）：进程由于运行错误（如段错误、非法操作）被终止；
• 被其他进程终止（Killed by another process）：如通过 kill(pid, SIGTERM) 信号强制结束；
• 被操作系统终止（Aborted by OS）：如内存溢出、非法访问、资源限制等被系统强制终止。

特殊进程

僵尸进程（Zombie Process）

定义

当一个子进程执行完毕（终止）后，其退出信息（如退出码）还没被父进程回收（通过 wait() 或 waitpid()），该子进程就进入僵尸状态，成为 僵尸进程。 它在 进程表中保留一项记录，用于父进程获取信息。

带来的问题

僵尸进程已经终止，不会占用CPU和内存，但也会有其他的问题：

• 僵尸进程会占用系统的进程表项（PCB，用于保存退出状态），而进程表项数量是有限的；
• 如果大量僵尸进程堆积，可能会导致 系统无法创建新进程，引发系统资源耗尽；
• 极端情况下可能导致系统不稳定甚至崩溃。

解决方案

1. 让父进程调用 wait() / waitpid() 回收子进程资源；
2. 如果父进程忘记回收，可以杀掉父进程，让子进程变成 孤儿进程，由 init（或 systemd）接管后，init 会负责回收；
3. 使用信号机制（如 SIGCHLD）信号通知父进程子进程已退出，触发回收机制；

孤儿进程（Orphan Process）

定义

当一个子进程还在运行，而它的父进程已经退出，该子进程会成为孤儿进程。

操作系统会自动将其交给 PID 为 1 的 init/systemd 进程 进行接管和管理。

带来的问题

• 孤儿进程不会像僵尸进程那样占用系统资源，因为 init/systemd 会自动回收它们的状态；

• 但如果这些孤儿进程本身是无意义的或无限循环，可能会导致：

• 占用大量 CPU 或内存资源；
• 增加系统负担，系统性能下降。

解决方案

1. 定期检查系统中 PPID=1 的进程（ps -ef | awk '$3==1'）；
2. 如果是异常程序导致的，应修复程序逻辑或添加守护策略；
3. 可使用 kill 杀掉异常的孤儿进程。

$3 表示第三列，也就是 PPID（父进程 ID），当该值为 1 时，表示其父进程是 init（PID 为 1）。

切换与上下文

进程的切换过程

进程切换是指 CPU 从当前正在运行的进程切换到另一个进程的过程，导致运行环境发生实质性变化。

过程步骤解释如下：

1. 保存处理机上下文 保存当前进程的 CPU 寄存器状态（包括 PC、SP、通用寄存器等）到该进程的 PCB 中。

2. 更新 PCB 信息 修改当前进程的状态（如从“运行”改为“就绪”或“阻塞”），并记录相关信息。

3. 将 PCB 移入对应队列

• 如果是主动等待资源 → 阻塞队列
• 如果是时间片用完 → 就绪队列

4. 选择新的进程并更新其 PCB

• 调用调度算法（如 CFS、RR）从就绪队列选中下一个进程。
• 将选中的进程 PCB 状态更新为“运行”。

5. 更新内存管理的数据结构

• 切换页表（Page Table Base Register）以映射新进程的虚拟内存空间。
• TLB（Translation Lookaside Buffer）失效，需要刷新。

6. 恢复处理机上下文

• 加载目标进程的上下文（寄存器、PC、SP 等）
• 跳转执行

调度 vs 切换

线程的切换过程

线程切换本质是上下文的切换，但比进程切换更轻量，不涉及内存空间的切换。它主要通过保存和恢复 TCB 中的寄存器等执行上下文实现。如果两个线程属于不同进程，还涉及进程的切换；但如果属于同一进程，则只切换线程上下文。

线程切换是指 CPU 从一个线程切换到另一个线程的过程，它涉及的主要是：

1. 保存当前线程的执行上下文（如寄存器、程序计数器 PC、栈指针 SP）
2. 更新当前线程的 TCB 状态
3. 选择另一个线程（调度）
4. 恢复新线程的上下文
5. 切换 CPU 执行控制权

上下文信息

线程切换涉及上下文保存，主要包括：

进程 vs 线程切换的区别

进程/线程通信与同步

通信（IPC）方式

进程间通信方式

线程间通信方式

线程属于同一进程，天然共享内存空间，因此通信本质上是「对共享数据的读写」+「同步机制」的组合。

总结对比

进程同步

临界资源

一次仅允许一个进程使用的资源。

同步遵循的准则

1. 空闲让进：临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区。
2. 忙则等待：当已有进程进入临界区时，其他试图进入临界区的进程必须等待。
3. 有限等待：对请求访问的进程，应保证能在有限时间内进入临界区。
4. 让权等待：当进程不能进入临界区时，应立即释放处理器，防止进程忙等待。

实现临界区互斥的基本方法

• 进程同步（Process Synchronization）：指的是在多个进程共享资源（如临界资源）时，为了避免竞态条件（Race Condition），需要通过同步机制来协调进程的执行顺序。

• 互斥（Mutual Exclusion）：同步的一个重要目标，确保一次只能有一个进程进入临界区访问共享资源。

软件实现方法

锁

基本内容

锁是并发控制机制，用于控制多个线程/进程对共享资源的访问，防止出现竞态条件、数据不一致等问题。

常见锁

• 互斥锁（Mutex）：只能一个线程持有，用于互斥访问资源。
• 读写锁（RWLock）：支持多个读线程并发访问，但写时独占。
• 自旋锁（Spinlock）：忙等待，不释放 CPU，适合锁时间短的场景。它是一种非阻塞的互斥锁，当一个线程尝试获取锁时，如果锁已被其他线程持有，它不会挂起（阻塞）当前线程，而是会在原地不断循环（“自旋”）检查锁是否被释放。
• 递归锁：同一线程可以多次加锁，不会死锁。
• 悲观锁 / 乐观锁：见下文。

锁的优缺点

好处

坏处

悲观锁 vs 乐观锁

死锁

概念

死锁（Deadlock） 是指多个进程/线程因争夺资源而造成的一种互相等待的现象，即每个进程都在等待其他进程释放它自己需要的资源，从而导致所有进程都无法继续执行。

导致进程/线程出现错误或者异常的场景除了死锁还有：

• 饥饿：由长期得不到想要的资源，某进程无法向前推进的现象。
• 死循环：某进程执行过程中一直跳不出某个循环的现象。

相同点

• 都是进程无法顺利向前推进的现象(故意设计的死循环除外)。

区别

• 死锁的发生至少要有两个或两个以上的进程
• 饥饿的发生可能只有一个进程
• 死锁和饥饿是管理者（操作系统）的问题，死循环是被管理者（程序逻辑错误，是程序员）的问题

死锁的四个必要条件（同时满足才可能发生死锁）

四个条件必须同时成立才会产生死锁，破坏其中任一即可避免死锁。

死锁的处理策略

预防死锁

通过破坏死锁的四个必要条件之一或多个来从根本上避免死锁的发生。

1. 破坏“互斥条件”

• 尽量使用可共享资源（如只读文件、缓存等），多个进程可同时访问。
• 但实际很多资源本身无法共享（如写文件、打印机），因此此方法适用范围有限。

2. 破坏“不可剥夺条件”

• 如果一个进程请求新资源失败，则主动释放已占资源并等待重试。
• 系统需支持资源状态保存与恢复，适用于可中断型资源（如内存页、CPU 时间片）。

3. 破坏“请求并保持条件”

• 进程在启动时一次性申请所需全部资源，若不能满足则等待所有资源就绪再执行。
• 降低灵活性，但能有效防止因边申请边持有造成的资源环。

4. 破坏“循环等待条件”

• 为所有资源统一编号，进程按照编号升序申请资源，禁止逆序申请。
• 常用于多线程加锁场景（锁 A → 锁 B，避免锁 B → 锁 A 形成死锁链）。

避免死锁

1. 破坏“循环等待”

• 规定所有资源必须按统一顺序申请，防止环形等待。

2. 破坏“占有且等待”

• 进程在申请新资源前必须一次性申请完，或先释放已有资源后再申请。

3. 使用银行家算法

• 模拟每次资源分配，若发现分配后系统可能进入死锁状态，则拒绝当前请求。

4. 采用锁顺序规则

• 多线程程序中，所有线程按照统一顺序加锁。

解除死锁

1. 终止进程

• 终止部分或全部死锁相关进程，释放资源，打破循环等待。
• 可以优先终止低优先级进程或计算开销较小的进程。

2. 资源剥夺

• 强制从部分进程中回收资源，使其他进程得以继续执行。

3. 进程回滚

• 将某些进程恢复到以前的某个安全状态，重新执行避免死锁。

​

阅读原文：https://mp.weixin.qq.com/s/jPXJwAoAt2lUx3IcItecOg