# 第二章 进程、线程与作业

> 本章是操作系统的核心章节，围绕"运行中的程序如何被管理"这一中心问题，从多道程序设计的需求出发，引出**进程**这一最核心概念，再扩展到**线程**和**作业**。全章内容在考试中出现频率极高，是后续章节（调度、同步、通信、死锁、内存管理）的基础。

---

## 一、知识讲解

### 2.1 多道程序设计（Multi-programming）

#### 2.1.1 单道程序设计的缺点

**单道程序设计**：内存中同时只有一道程序，程序独占所有资源顺序执行。

- **处理机（CPU）利用率低**：当程序进行 I/O 操作时，CPU 处于空闲等待状态。
- **设备利用率低**：I/O 设备串行使用，外设与 CPU 不能并行工作。
- **内存利用率低**：内存中仅有一道程序，占用空间有限。

举例：运行程序 A 时，若 A 在 t1–t2 时间段使用设备1，则 t1–t2 内 CPU 和设备2 完全空闲，整体效率很低。

#### 2.1.2 多道程序设计的提出

**多道程序设计**：内存中同时存放多道程序，使它们交替运行（宏观同时，微观串行），使 CPU 与 I/O 设备并行工作，从而提高资源利用率。

- **核心思想**：当一道程序因 I/O 暂停时，CPU 可立即转去运行另一道程序。
- **效果**：处理机、设备、内存等资源利用率显著提升，系统效率（吞吐量）提高。

> 通俗理解：A 程序等打印机时，B 程序正在用 CPU 算数学——两不耽误。

#### 2.1.3 多道程序设计的道数问题

- **道数过少**：资源利用率仍低。
- **道数过多**：系统开销（system overhead）增大，进程切换频繁，程序响应速度下降。
- **结论**：道数应与系统资源数量相当。

#### 2.1.4 多道程序设计带来的新问题

| 资源 | 需解决的问题 |
|------|--------------|
| 处理机 | 程序个数 > 处理机个数，如何分配？（CPU 调度） |
| 内存 | 地址空间的相对独立性、共享性；内存与外存（swap space）的分配与去配 |
| 设备 | 分配策略；I/O 控制 |

> 这三大问题分别引出后续章节的"处理机管理（进程与调度）"、"存储管理"、"设备管理"。

---

### 2.2 进程的引入

#### 2.2.1 进程的概念

**进程（Process）** 是操作系统中最基本、最重要的概念之一。

- **定义1**：可参与并发执行的程序称为进程。
- **定义2**：进程是**具有一定独立功能的程序关于一个数据集合的一次运行活动**。

定义强调两方面：
1. **动态性**：进程是"执行中的程序"，不是静态代码。
2. **并发性**：进程可与其他进程同时执行（宏观同时）。

**程序 vs 进程**：
- 程序是静态的指令集合，可长期保存在磁盘上。
- 进程是动态的执行实体，有从创建到消亡的生存期。
- 一个程序可对应多个进程（如多个用户运行 vi）；一个进程在某时刻只能执行一个程序。

#### 2.2.2 并发（Concurrent） vs 并行（Parallel）

| 概念 | 含义 | 是否需要多 CPU |
|------|------|----------------|
| 并发 | 宏观同时，**交替执行**（分时复用） | 否 |
| 并行 | 微观同时，真正同时执行 | 是 |

> 单 CPU 系统上"边听音乐边写文档"是**并发**；多核 CPU 上两件事同时跑是**并行**。

#### 2.2.3 多道系统中程序的运行特点

- 程序不断**推进 → 暂停 → 推进 → 暂停**。
- **暂停时**必须保存现场（PSW、PC、寄存器等），便于恢复。
- **推进时**恢复现场。
- **暂停原因**：
  1. 自身原因：等待资源、启动 I/O。
  2. 被剥夺 CPU——给其他程序运行机会。

#### 2.2.4 进程状态及状态转换

**基本三状态**：

| 状态 | 英文 | 含义 |
|------|------|------|
| **运行态** | RUN | 占有 CPU，正在向前推进 |
| **就绪态** | READY | 具备运行条件，只差 CPU |
| **等待态**（阻塞态） | WAIT | 等待某事件发生（如 I/O 完成） |

**状态转换**（共 4 种）：

| 转换 | 触发条件 |
|------|----------|
| 就绪 → 运行 | 获得处理机（被调度） |
| 运行 → 就绪 | 时间片到，被剥夺处理机 |
| 运行 → 等待 | 申请资源未得到 / 启动 I/O |
| 等待 → 就绪 | 资源得到 / I/O 中断事件发生 |

> **重要注意点**：
> 1. 状态转换由**操作系统**完成，对用户**透明**。
> 2. **就绪 → 等待** 不存在！就绪态进程没有运行，不可能在等待某事件时突然被阻塞。
> 3. **等待 → 运行** 不存在！等待态必须先转就绪，再等调度才能运行。

**考虑创建与终止的五状态模型**：

在基本三状态基础上加上：
- **初创（New）**：进程刚被创建，尚未就绪。
- **终止（Terminated）**：进程已结束，等待善后处理。

#### 2.2.5 进程控制块（PCB, Process Control Block）

**定义**：**PCB 是标志进程存在的数据结构**，其中保存系统管理进程所需的全部信息。

> **建立进程 = 建立 PCB**；**撤销 PCB = 撤销进程**。

**PCB 的典型内容**：

| 类别 | 内容 |
|------|------|
| 标识信息 | 进程标识（pid）、家族联系（父进程 pid）、所属用户（uid） |
| 状态信息 | 进程状态（RUN/READY/WAIT 等） |
| 现场信息 | PSW、PC、通用寄存器、栈指针等 |
| 地址信息 | 程序段、数据段、堆栈段地址 |
| 调度信息 | 优先级、调度参数 |
| 资源信息 | 打开文件、消息指针、信号 |
| 队列信息 | 就绪/等待队列指针 |

**PCB 的组织方式**：
- 链接方式：同状态的 PCB 链成队列（就绪队列、等待队列）。
- 索引方式：建立索引表。

#### 2.2.6 进程的组成与上下文

**进程的组成**（三部分）：

1. **PCB**：进程存在的标志。
2. **程序**（代码 code + 数据 data）。
3. **堆栈**（stack + heap）。
   - **栈**：保存返回点、参数、返回值、局部变量。
   - **堆**：动态分配的变量。

**进程影像（Process Image）**：进程的程序（代码和数据）部分。

**进程的物理实体 + 支持进程运行的物理环境 = 进程上下文（Process Context）**。
- 包括：PCB + 程序 + 系统环境（地址空间、系统栈、打开文件表等）。

**上下文切换（Context Switch）**：由一个进程的上下文转到另一个进程的上下文。
**系统开销（System Overhead）**：操作系统为管理工作所花费的时间和空间。

#### 2.2.7 进程的队列

- **就绪队列**：系统中一个或多个（取决于调度算法）。
- **等待队列**：每个等待事件一个队列（如等待打印机、等待磁盘 I/O）。
- **运行指示字**：每个处理机一个，指向当前运行进程的 PCB。
- 队列中的 PCB 不一定 FIFO，可能按优先级排，单向或双向链表。

#### 2.2.8 进程的类型与特征

**按类型分**：

| 类型 | 功能 | 例子（UNIX） |
|------|------|---------------|
| **系统进程** | 运行 OS 程序，完成管理/服务功能 | #0 sched、#1 init |
| **用户进程** | 运行用户程序，为用户服务 | vi、shell、cc |

**进程的特征（五大特征）**：

1. **并发性**：可与其他进程一道向前推进。
2. **动态性**：动态产生与消亡，生存期内状态动态变化（**最基本特征**）。
3. **独立性**：一个进程是可以调度的基本单位。
4. **交往性**：同时运行的进程可能发生相互作用。
5. **异步性**：进程以各自独立、不可预知的速度向前推进。
6. **结构性**：每个进程有一个 PCB。

#### 2.2.9 进程间相互联系与相互作用

**相互联系**：

- **相关进程**：同一家族，可共享文件，需相互通信、协调推进。父进程可监视子进程。
- **无关进程**：无逻辑关系、同时执行。可能产生资源竞争（互斥、死锁、饿死）。

**相互作用**：

- **直接相互作用**：发生在相关进程之间，通过 send/receive、信号等显式通信。
- **间接相互作用**：通过共享资源（变量、文件）隐式发生，需互斥访问。

#### 2.2.10 进程的创建与撤销

**进程创建**：
1. 建立 PCB；
2. 分配内存；
3. 加载程序；
4. 入就绪链。

UNIX 系统中：
- `pid = fork()`：创建子进程（复制父进程），子进程是父进程的"复制品"。
  - 返回值：父进程中返回子进程 pid（>0），子进程中返回 0。
- `execl(prog, arg0, ..., 0)`：在子进程中加载并执行新程序（覆盖原程序，从头执行）。

**进程撤销**：
- 去配资源、撤销 PCB、通知父进程。
- UNIX：`exit(status)` 自我终止；`kill` 由其他进程终止。

> **进程家族树**：除 0 号（init）外，所有进程由父进程创建，形成家族关系。

#### 2.2.11 UNIX 进程组成（映像）

UNIX 中进程映像由三部分组成：
1. **proc 结构**（常驻内存）：无论进程在内存还是外存都需的信息（p_stat、p_pid、p_ppid、p_pri、p_wchan 等）。
2. **user 结构**（可换出）：仅当进程在内存时需要（u_uid、u_ofile、u_arg、u_tsize/dsize/ssize、u_procp 等）。
3. **text 结构**：代码段（x_daddr、x_size、x_count）。

#### 2.2.12 fork / vfork 的区别

| 特性 | fork | vfork |
|------|------|-------|
| 是否复制地址空间（code+data+stack） | 是 | 否 |
| 是否复制控制结构（proc、user） | 是 | 是 |
| 父子进程数据 | 各有独立拷贝 | **共享** |
| 典型用途 | 不加载新程序时 | 子进程立即 exec |

> vfork 设计目的：避免 fork 后立刻 exec 造成无意义的复制浪费。子进程与父进程共享地址空间，子进程必须立即调用 `execve` 改变虚拟地址空间。

---

### 2.3 线程与轻进程（Thread & Light-Weighted Process）

#### 2.3.1 线程的引入

**进程切换的问题**：
- 进程上下文内容多（PCB + 程序 + 系统栈 + 打开文件表 + ...），切换**开销大、笨重**。
- 相关进程之间耦合关系差，通信代价高。

**解决方案——多线程（Multi-threading）**：
- 同一进程内包含多个线程，**共享进程的地址空间和资源**。
- 线程上下文只涉及**寄存器和用户栈**，切换速度快。
- 同一进程内线程间通信方便（共享数据空间即可）。

#### 2.3.2 线程的概念

**线程（Thread）**：**进程内一个相对独立的执行流**。

| 维度 | 进程 | 线程 |
|------|------|------|
| **资源分配单位** | 是 | 否（共享所属进程的资源） |
| **执行/调度单位** | 是 | 是 |
| **拥有独立地址空间** | 是 | 否（共享进程的地址空间） |
| **切换开销** | 大 | 小（light-weighted） |
| **通信方式** | IPC、共享内存等 | 共享进程数据空间，直接读写 |

**多线程优点**：
1. 切换速度快（地址空间不变）。
2. 系统开销小。
3. 通信容易（共享数据空间）。

#### 2.3.3 线程的结构

- **多进程视图**：每个进程有独立的内存、代码、栈、寄存器、堆。
- **多线程视图**：同一进程内的多个线程**共享代码段、数据段、堆**，各自有**独立的栈和寄存器**（PC、SP 等）。

#### 2.3.4 线程控制块（TCB, Thread Control Block）

**TCB**：标志线程存在的数据结构，包含线程管理所需的全部信息。

**TCB 典型内容**：
- 线程标识 tid
- 线程状态
- 调度参数（优先级）
- 现场信息（通用寄存器、PC、SP）
- 链接指针（指向同队列中其他 TCB）

**TCB 存放位置**：
- **用户级线程**：目态空间（用户态运行时系统）。
- **核心级线程**：系统空间（内核）。

#### 2.3.5 线程的实现

**（1）用户级线程（User-Level Thread）**

- **实现**：基于 library 函数（在用户空间），OS 不可见。
- TCB 在用户空间；线程创建、撤销、状态转换均在目态完成。
- **优点**：
  - 不依赖 OS，调度灵活，可为不同线程定制调度算法。
  - 同一进程内线程切换速度快，**不需进入内核**。
- **缺点**：
  - 同一进程内多线程**不能真正并行**（OS 调度单位仍是进程）。
  - 一个线程进入系统（系统调用）受阻，**同进程其他线程全部被阻塞**。

**（2）核心级线程（Kernel-Level Thread）**

- **实现**：基于系统调用，OS 直接管理。
- TCB 在系统空间；创建、撤销、状态转换由 OS 完成。
- **优点**：
  - 同一进程内多线程可**真正并行**（多 CPU 上）。
  - 一线程阻塞，**其他线程可继续**。
- **缺点**：
  - 系统开销大，切换需陷入内核。
  - 调度算法不能灵活控制（由 OS 决定）。

**（3）混合线程（Hybrid, 以 Solaris 为代表）**

Solaris 三层结构：
- **User Level Thread（ULT）**：由 Lib 程序支持（创建、调度）。
- **Light Weight Process（LWP）**：中间层，每个 task 至少一个 LWP；ULT 与 LWP **多对多**。
- **Kernel Level Thread（KLT）**：由内核支持；LWP 与 KLT **一对一**；KLT 与 CPU **多对多**。

> 只有与 LWP 关联的 ULT 才能真正推进；LWP 对 OS 可见，是 OS 调度的实体。

#### 2.3.6 线程的应用

- 适合"内在的多控制流、需要共享数据"的场景。
- **生产-消费问题**：多线程比多进程**快约 100 倍**（共享缓冲区的开销远小于 IPC）。
- 提高处理机与设备的并行性，在多处理机环境特别有效。
- **经典例子**：
  - Word 字处理：交互编辑（T1）、词法检查（T2）、定时保存（T3）三个线程。
  - HTTP Server：每个 HTTP 请求"弹出"一个新线程处理。

---

### 2.4 作业（Job）

#### 2.4.1 作业的基本概念

- **作业**：用户要求计算机系统为其完成的**计算任务集合**。
- **作业步（Job Step）**：作业处理过程中一个相对独立的步骤；**一般一个作业步可由一个进程完成**；某些作业步之间可并行。
- **作业分类**：
  - **批处理作业**：脱机工作，通过作业说明书提交。
  - **交互式作业**：联机工作，通过终端命令交互。

#### 2.4.2 批处理作业

- **作业控制语言（JCL）**：描述批处理作业控制意图的语言。
- **作业说明书**：JCL 语句的序列，常以特殊符号起始（如 `$`）。

**典型 JCL 例子**：
```
$JOB J1
$FORTN ...
$LINK ...
$EXEC ...
$ENDJOB
```

- **作业控制程序**：解释并处理作业说明书的程序。
- **作业控制进程**：执行作业控制程序的进程。

**作业控制进程工作流程**：
读入作业内容 → 释放输入井空间 → 顺取 JCL 语句 →（若是结束语句则执行该作业步 → 申请输出井空间 → 输出结果 → 自我终止）→ 循环。

#### 2.4.3 交互式作业

- **帐户管理**：`/etc/passwd` 文件（用户名、口令、用户根目录、同组用户、余额等）。
- **创建**：用户提供（用户名、口令、资金）→ 系统操作员建立根目录、填 passwd。
- **撤销**：删除用户目录及所有文件，清除 passwd 对应 entry。
- **注册/注销**：
  - 注册：`logon: 用户名` + `password: ********`。
  - 注销：显式（`logoff`）或隐式（长时间无输入，如 5 分钟）。

**命令解释程序（Shell）工作流程**：提示符 → 读入命令 → 分析 →（内部命令直接处理 / 外部命令建立子进程）→ 等待子进程结束 → 记帐 → 循环。

#### 2.4.4 作业、进程、线程的关系（小结）

| 关系 | 说明 |
|------|------|
| **作业与进程** | 作业进入内存后变为进程；**一个作业通常对应多个进程** |
| **进程与线程** | 一个进程一般包含多个线程，至少一个；不支持多线程的系统可视为单线程进程 |
| **作业、进程、线程** | 作业是面向用户的任务单位；进程是系统资源分配和独立运行单位；线程是 CPU 调度单位 |

---

### 2.5 现代系统中的进程/线程（Java、Linux、Windows）

#### 2.5.1 Java 线程

**Java 线程四种基本状态**：

| 状态 | 含义 |
|------|------|
| **New** | 新建，尚未启动 |
| **Runnable** | 可运行（Java 不严格区分就绪与运行） |
| **Blocked** | 封锁状态（等待锁、I/O、sleep、suspend 等） |
| **Dead** | 终止 |

**状态转换**：New → start() → Runnable；Runnable → sleep()/suspend()/I/O → Blocked；Blocked → IO 完成/Resume → Runnable；Runnable → stop() → Dead。

**Java 线程与 JVM**：
- Java 线程由 JVM 支持，JVM 位于 OS 之上。
- Java 线程与 OS 线程的映射由 JVM 决定：
  - Windows NT 的 JVM：**一对一**。
  - Solaris 的 JVM：**多对多**。

#### 2.5.2 Linux 进程与线程

- **关键思想**：Linux 内核中**进程与线程具有统一的表示**（均为 `task_struct`）。
- **差异体现**：通过与 `fork` 不同的 `clone` 系统调用区分。
  - `pid = clone(function, stack_ptr, sharing_flag, arg)`
  - `sharing_flag`：`CLONE_VM`（共享内存）、`CLONE_FILES`（共享文件）、`CLONE_SIGHAND`（共享信号处理）、`CLONE_PID`（共享 pid）等。
- `fork` 可视为 `clone` 在所有 sharing flag 关闭时的特例。

#### 2.5.3 Windows 10 进程、线程与纤程

**Win32 进程创建过程**：
应用调用 `CreateProcess` → Win32 子系统 → 进程管理器 → 对象管理器（OM）创建进程对象 → 进程管理器为该进程创建线程 → Win32 将进程/线程句柄返回给应用。

**Windows 线程状态**（5 态或更多）：

| 状态 | 含义 |
|------|------|
| **初始（Initialized）** | 线程对象刚创建 |
| **就绪（Ready）** | 等待 CPU |
| **备用（Standby）** | 已选中，下一个时间片运行（每个 CPU 一个） |
| **运行（Running）** | 正在执行 |
| **等待（Waiting）** | 等待某对象（信号、I/O 等） |
| **转换（Transition）** | 等待栈在外（线程在内核态等待，且其用户栈不在内存） |
| **终止（Terminated）** | 执行完，等待回收 |

**转换关系**：初始→就绪（创建线程对象）→备用（入就绪队列）→运行（被选中）→就绪/等待（剥夺/等待事件）→等待→就绪（唤醒）→运行（切换）→终止（执行完）。

---

## 二、考点总结

### 考点1：进程的定义与基本特征

- **内容**：进程是具有一定独立功能的程序关于一个数据集合的一次运行活动；强调**动态性**和**并发性**。基本特征：动态性、并发性、独立性、交往性、异步性、结构性。
- **考查方式**：选择、填空、简答。
- **可能的题目**：
  1. **填空**：进程是程序在某个数据集合上的一次_**运行活动**__，是系统进行资源分配和调度的基本单位。
  2. **选择**：下面哪项**不是**进程的特征？（D）A. 动态性  B. 并发性  C. 独立性  D. 静态性
  3. **简答**：进程与程序的区别是什么？——程序是静态的指令集合，可长期保存；进程是动态的执行实体，有生存期；进程 = 程序 + PCB + 上下文；一个程序可对应多个进程，一个进程在某时刻对应一个程序。

### 考点2：进程三种基本状态及转换

- **内容**：就绪 R、运行 RUN、等待 W。转换有 4 种：就绪→运行、运行→就绪、运行→等待、等待→就绪。
- **考查方式**：选择、画图、填空。
- **可能的题目**：
  1. **画图**：画出进程三种基本状态转换图（含四个箭头及触发条件）。
  2. **选择**：下列状态转换中**不可能**发生的是（B）A. 运行→就绪  B. 就绪→等待  C. 等待→就绪  D. 运行→等待
  3. **填空**：进程由**运行**态到**等待**态是由于申请资源未得到或启动 I/O；由**等待**态到**就绪**态是因事件发生（如 I/O 完成）。

### 考点3：PCB（进程控制块）

- **内容**：PCB 是标志进程存在的数据结构；含 pid、状态、现场、地址、调度、资源、队列指针等信息。**建立进程 = 建立 PCB，撤销 PCB = 撤销进程**。
- **考查方式**：选择、填空、简答。
- **可能的题目**：
  1. **选择**：在操作系统中，进程存在的唯一标志是（B）A. 程序段  B. PCB  C. 数据段  D. 堆栈
  2. **简答**：PCB 的主要作用是什么？包含哪些信息？——PCB 是进程存在的标志，OS 通过 PCB 管理和控制进程；含进程标识、状态、现场（PC、PSW、寄存器）、地址、调度参数、打开文件、队列指针等。
  3. **填空**：建立进程实质上是建立**PCB**；撤销进程实质上是撤销**PCB**。

### 考点4：并发与并行的区别

- **内容**：并发是宏观同时微观交替，不要求多 CPU；并行是微观真正同时，要求多 CPU。
- **考查方式**：选择、填空、简答。
- **可能的题目**：
  1. **选择**：以下描述属于"并行"的是（C）A. 单核 CPU 上多道程序交替执行  B. 分时系统  C. 多核 CPU 上多个程序同时执行  D. 中断处理
  2. **填空**：单处理机系统上的多道程序设计体现的是**并发**性。

### 考点5：进程上下文与上下文切换

- **内容**：进程上下文 = 进程物理实体（PCB+程序）+ 支持进程运行的物理环境；上下文切换 = 由一个进程的上下文转到另一个进程的上下文，会产生系统开销。
- **考查方式**：选择、简答。
- **可能的题目**：
  1. **简答**：什么是进程上下文切换？开销来自哪些方面？——OS 保存当前进程的 CPU 现场（PC、PSW、寄存器等）并加载下一个进程的现场；开销来自保存/恢复现场、内核态切换、Cache/TLB 失效等。

### 考点6：进程与程序的联系与差别

- **内容**：进程包含一个程序；程序静态，进程动态；程序可长期保存，进程有生存期；一个程序对应多个进程，一个进程只能执行一个程序。
- **考查方式**：选择、简答、辨析。
- **可能的题目**：
  1. **判断**：一个程序只能对应一个进程。（错）多用户多次运行同一程序产生多个进程。
  2. **简答**：进程和程序的主要区别。

### 考点7：进程家族与 fork/exec

- **内容**：除 0 号 init 外所有进程由父进程创建；`fork()` 复制父进程，返回值在父进程中为子进程 pid（>0），子进程中为 0；`execl()` 加载并执行新程序（覆盖原程序）；`exit()` 自我终止；`wait()` 等待子进程结束。
- **考查方式**：程序分析题、简答。
- **可能的题目**：
  1. **程序分析**：写出 `pid = fork();` 后父子进程各自看到的 pid 值。父进程：pid > 0（子进程编号）；子进程：pid = 0。
  2. **简答**：fork 与 vfork 的区别。fork 复制地址空间（code+data+stack），父子进程数据独立；vfork 不复制地址空间，父子共享，子进程必须立即 execve。

### 考点8：线程的概念与特点

- **内容**：线程是进程内一个相对独立的执行流，是 CPU 调度单位；同一进程内线程共享地址空间和资源；线程切换开销小、通信易。
- **考查方式**：选择、填空、简答。
- **可能的题目**：
  1. **选择**：以下关于线程的叙述中，**错误**的是（D）A. 线程是 CPU 调度的基本单位  B. 同一进程内的线程共享地址空间  C. 线程切换比进程切换开销小  D. 线程是资源分配的基本单位
  2. **填空**：进程是**资源分配**单位，线程是**执行（调度）**单位。

### 考点9：进程 vs 线程对比

- **内容**：

| 维度 | 进程 | 线程 |
|------|------|------|
| 资源分配单位 | 是 | 否（共享所属进程） |
| 调度单位 | 是 | 是 |
| 地址空间 | 独立 | 共享（同一进程内） |
| 切换开销 | 大 | 小 |
| 通信方式 | 复杂（IPC） | 简单（共享数据） |

- **考查方式**：选择、简答、表格填空。
- **可能的题目**：
  1. **简答**：为什么引入线程？——减小进程切换开销；提高并发度；同进程内线程通信方便。

### 考点10：用户级线程 vs 核心级线程

- **内容**：

| 特性 | 用户级线程 | 核心级线程 |
|------|------------|------------|
| 实现 | 用户态 Library | 系统调用 |
| TCB 位置 | 用户空间 | 系统空间 |
| 切换是否进内核 | 否 | 是 |
| 切换速度 | 快 | 慢 |
| 同一进程多线程并行 | 否 | 是 |
| 一线程阻塞影响 | 阻塞同进程所有线程 | 其他线程可继续 |
| 调度灵活性 | 高 | 受 OS 限制 |

- **考查方式**：选择、简答、对比表。
- **可能的题目**：
  1. **选择**：用户级线程的主要缺点是（C）A. 切换慢  B. 不能并发  C. 同一进程内一线程阻塞会导致整个进程阻塞  D. 占用系统资源多
  2. **简答**：用户级线程与核心级线程的优缺点对比。

### 考点11：混合线程（Solaris 模型）

- **内容**：ULT 与 LWP 多对多；LWP 与 KLT 一对一；KLT 与 CPU 多对多；只有与 LWP 关联的 ULT 才能推进。
- **考查方式**：选择、填空、画图。
- **可能的题目**：
  1. **填空**：在 Solaris 混合线程模型中，LWP 是连接用户级线程和**核心级线程**的中间层。
  2. **画图**：画出 Solaris 三层线程模型（ULT → LWP → KLT → CPU）的多对多映射。

### 考点12：作业的概念与分类

- **内容**：作业是用户要求计算机完成的任务集合；作业步是作业内相对独立的步骤，一般一个作业步由一个进程完成；分为批处理作业和交互式作业。
- **考查方式**：选择、填空、简答。
- **可能的题目**：
  1. **填空**：作业由内存进入系统后变为**进程**；一个作业通常对应**多个**进程。
  2. **选择**：下列关于作业的叙述**错误**的是（B）A. 一个作业可包含多个作业步  B. 一个作业步必须由多个进程完成  C. 作业是用户提交任务的基本单位  D. 批处理作业通过 JCL 描述

### 考点13：批处理作业与 JCL

- **内容**：JCL 是描述批处理作业控制意图的语言；作业说明书是 JCL 语句序列；由作业控制程序解释执行；作业控制进程执行作业控制程序。
- **考查方式**：填空、简答。
- **可能的题目**：
  1. **填空**：描述批处理作业控制意图的语言称为**JCL（作业控制语言）**；JCL 语句的序列称为**作业说明书**。
  2. **简答**：简述批处理作业的处理流程（作业控制进程工作流程）。

### 考点14：交互式作业与命令解释程序

- **内容**：交互式作业通过终端命令与系统交互；需注册（logon/password）和注销（logoff 或超时隐式注销）；命令解释程序（Shell）负责读入、分析、执行命令；内部命令直接处理，外部命令建立子进程。
- **考查方式**：填空、简答。
- **可能的题目**：
  1. **简答**：简述命令解释程序的工作流程。提示符 → 读入命令 → 分析 →（内部命令处理 / 外部命令建子进程）→ 等待子进程结束 → 记帐 → 循环。
  2. **填空**：交互式作业的隐式注销通常发生在**长时间无输入**时。

### 考点15：作业、进程、线程关系总结

- **内容**：作业 → 进程 → 线程。作业是面向用户的任务单位，作业进入内存后变为进程；进程是资源分配单位，进程内可有多个线程；线程是调度单位。
- **考查方式**：简答、画关系图。
- **可能的题目**：
  1. **简答**：简述作业、进程、线程三者之间的关系。
  2. **画图**：画出作业 → 作业步 → 进程 → 线程 的包含与映射关系。

### 考点16：UNIX 进程映像（proc/user/text）

- **内容**：proc 常驻内存（无论进程在内存还是外存都需要的信息：p_stat、p_pid、p_ppid 等）；user 可换出（仅进程在内存时需要：u_uid、u_ofile、u_procp 等）；text 是代码段（x_count 引用计数）。
- **考查方式**：选择、填空。
- **可能的题目**：
  1. **选择**：UNIX 进程映像中，**常驻内存**的部分是（A）A. proc 结构  B. user 结构  C. text 结构  D. 用户栈
  2. **填空**：UNIX 中保存进程打开文件表的是 **user** 结构。

### 考点17：Linux 的 clone 与统一表示

- **内容**：Linux 进程与线程在系统内部统一表示为 `task_struct`；通过 `clone` 调用及 sharing flag（CLONE_VM、CLONE_FILES、CLONE_SIGHAND、CLONE_PID）区分。
- **考查方式**：选择、填空、简答。
- **可能的题目**：
  1. **简答**：Linux 中进程与线程在系统内部是如何表示的？它们如何区分？——统一表示为 task_struct；通过 clone 系统调用的 sharing_flag 区分共享资源范围。

### 考点18：Windows 线程状态

- **内容**：Windows 线程有 6 种状态：初始、就绪、备用、运行、等待、转换、终止。
- **考查方式**：画图、选择。
- **可能的题目**：
  1. **画图**：画出 Windows 线程状态转换图（含各转换触发条件）。
  2. **填空**：Windows 中"备用（Standby）"状态表示线程**已被选中**为下一个时间片的执行者（每 CPU 一个）。

### 考点19：Java 线程状态

- **内容**：Java 线程 4 态：New、Runnable、Blocked、Dead。
- **考查方式**：选择、画图。
- **可能的题目**：
  1. **选择**：Java 线程调用 sleep() 后进入（D）A. New  B. Runnable  C. Dead  D. Blocked
  2. **画图**：画出 Java 线程状态转换图。

### 考点20：多道程序设计的道数与系统开销

- **内容**：道数过少资源利用率低；道数过多系统开销增大、响应速度下降；应与系统资源数量相当。
- **考查方式**：简答、选择。
- **可能的题目**：
  1. **简答**：多道程序设计的道数是否越多越好？为什么？——不是。道数过多会使进程切换频繁，系统开销增大，程序响应速度下降。

### 考点21：进程间相互作用

- **内容**：直接相互作用（相关进程间 send/receive/同步/互斥）；间接相互作用（通过共享资源）。
- **考查方式**：简答、举例。
- **可能的题目**：
  1. **简答**：进程间有哪两种相互作用方式？各举一例。——直接相互作用（相关进程间通信，如 send/receive、信号量同步）；间接相互作用（通过共享资源访问发生竞争，如打印机互斥使用）。

---

> **学习提示**：本章是 OS 课程的基石，后续"处理机调度"、"进程同步与通信"、"死锁"等章节都以本章的进程/线程概念为基础。复习时应重点理解**进程状态的转换图**、**PCB 作用**、**进程 vs 线程**、**用户级 vs 核心级线程**、**fork/exec 流程**、**作业与进程的关系**等核心考点。