vault backup: 2026-06-13 23:46:22

操作系统/06_进程控制/06_进程控制.md

@@ -0,0 +1,868 @@
+# 第06讲：进程控制
+
+> **本节目标**：理解进程的概念与生命周期，掌握 `fork()`、`exec()`、`wait()`、`exit()` 等进程控制系统调用，理解信号机制与僵尸进程，最终能实现一个简易 shell 和 daemon 进程。
+
+## 前置知识
+
+- [[03_C语言编程基础]] -- C 语言指针、数组、字符串操作
+- [[07_多线程编程]] -- 线程与进程的对比
+
+---
+
+## 一、进程概念
+
+### 1.1 什么是进程
+
+**进程（Process）** 是程序的一次执行实例。程序是静态的代码文件，进程是动态的执行过程。当操作系统将程序加载到内存并开始执行时，就创建了一个进程。
+
+每个进程拥有独立的地址空间，包含以下组成部分：
+
+```mermaid
+graph TD
+    P[进程] --> T[代码段 Text]
+    P --> D[数据段 Data]
+    P --> H[堆 Heap]
+    P --> S[栈 Stack]
+    P --> PCB[PCB 进程控制块]
+
+    T -->|存放| T1[程序指令]
+    D -->|存放| D1[全局变量/静态变量]
+    H -->|动态分配| H1[malloc/free]
+    S -->|自动管理| S1[局部变量/函数调用]
+    PCB -->|记录| PCB1[PID/状态/寄存器/文件描述符]
+
+    style P fill:#fff3e0
+    style PCB fill:#e1f5fe
+```
+
+### 1.2 进程 vs 程序
+
+| 对比维度 | 程序（Program） | 进程（Process） |
+|----------|-----------------|-----------------|
+| 本质 | 静态的代码文件 | 动态的执行过程 |
+| 存储位置 | 硬盘 | 内存 |
+| 生命周期 | 长期保存 | 有创建、运行、终止 |
+| 对应关系 | 一个程序可对应多个进程 | 一个进程只对应一个程序 |
+| 包含内容 | 代码 + 数据 | 代码 + 数据 + 堆栈 + PCB |
+
+### 1.3 进程状态
+
+```mermaid
+stateDiagram-v2
+    [*] --> 创建: fork()
+    创建 --> 就绪: 分配资源
+    就绪 --> 运行: 调度器选中
+    运行 --> 就绪: 时间片用完
+    运行 --> 阻塞: 等待I/O
+    阻塞 --> 就绪: I/O完成
+    运行 --> 终止: exit()
+    终止 --> [*]
+
+    就绪: Ready
+    运行: Running
+    阻塞: Blocked/Waiting
+    终止: Terminated/Zombie
+```
+
+### 1.4 进程标识
+
+每个进程都有唯一的 **PID**（Process ID）。常用函数：
+
+```c
+pid_t getpid();    // 获取当前进程的 PID
+pid_t getppid();   // 获取父进程的 PID
+```
+
+---
+
+## 二、fork() -- 创建子进程
+
+### 2.1 基本原理
+
+`fork()` 是 Linux 中创建新进程的唯一方式。调用 `fork()` 后，操作系统会创建一个与父进程几乎完全相同的子进程。子进程获得父进程的代码段、数据段、堆栈的**副本**。
+
+**关键特性**：`fork()` 被调用一次，但**返回两次**：
+- 父进程中返回子进程的 PID（正整数）
+- 子进程中返回 0
+- 如果出错返回 -1
+
+```mermaid
+graph TD
+    A["父进程调用 fork()"] --> B{操作系统创建子进程}
+    B --> C["父进程：返回子进程 PID（>0）"]
+    B --> D["子进程：返回 0"]
+    C --> E["父子进程各自独立执行"]
+    D --> E
+
+    style A fill:#e1f5fe
+    style C fill:#fff3e0
+    style D fill:#e8f5e9
+```
+
+### 2.2 fork 基础示例
+
+参考 `实例源代码/chap5/fork1.c`：
+
+```c
+#include "wrapper.h"
+int main()
+{
+    pid_t pid;
+    int x = 1;
+
+    pid = fork();
+    if (pid == 0) {    // 子进程执行这段代码
+        x = x + 1;
+        printf("child: x=%d\n", x);   // 输出 child: x=2
+    }
+
+    if (pid > 0) {     // 父进程执行这段代码
+        x = x - 1;
+        printf("parent: x=%d\n", x);  // 输出 parent: x=0
+    }
+    sleep(10);  // 让父子进程都执行完代码
+}
+```
+
+**关键理解**：
+- `fork()` 后，父子进程拥有**独立的变量副本**
+- 子进程修改 `x` 不影响父进程的 `x`，反之亦然
+- 父子进程的执行顺序是不确定的，取决于调度器
+
+### 2.3 多次 fork 的进程数计算
+
+参考 `实例源代码/chap5/fork3.c`：
+
+```c
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+int main()
+{
+    fork();  // 第1次：2个进程
+    fork();  // 第2次：4个进程
+    fork();  // 第3次：8个进程
+    printf("hello \n");
+    sleep(10);
+    return;
+}
+```
+
+**进程树分析**：n 次 `fork()` 会产生 2^n 个进程。上面的代码执行 3 次 `fork()`，最终产生 2^3 = 8 个进程，每个进程打印一次 "hello"。
+
+```mermaid
+graph TD
+    P0["P0 (原始进程)"] -->|第1次fork| P1["P1"]
+    P0 -->|继续| P0a["P0"]
+    P0a -->|第2次fork| P2["P2"]
+    P0a -->|继续| P0b["P0"]
+    P1 -->|第2次fork| P3["P3"]
+    P1 -->|继续| P1a["P1"]
+    P0b -->|第3次fork| P4["P4"]
+    P1a -->|第3次fork| P5["P5"]
+    P2 -->|第3次fork| P6["P6"]
+    P3 -->|第3次fork| P7["P7"]
+
+    style P0 fill:#ffcdd2
+    style P1 fill:#e1f5fe
+    style P2 fill:#e1f5fe
+    style P3 fill:#e1f5fe
+    style P4 fill:#e8f5e9
+    style P5 fill:#e8f5e9
+    style P6 fill:#e8f5e9
+    style P7 fill:#e8f5e9
+```
+
+### 2.4 fork 的复杂示例
+
+参考 `实例源代码/chap5/fork2.c`：
+
+```c
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+int main()
+{
+    int pid;
+    pid = fork();      // 创建 P1
+    pid = fork();      // P0 和 P1 各创建一个子进程
+    if (pid > 0) fork(); // pid>0 的进程再创建一个子进程
+    printf("hello \n");
+    exit(0);
+}
+```
+
+**分析**：需要追踪每个进程的 `pid` 值来确定哪些进程会执行第三次 `fork()`。最终打印 6 个 "hello"。
+
+### 2.5 fork 的注意事项
+
+| 要点 | 说明 |
+|------|------|
+| 返回值判断 | 必须用 `if-else` 分别处理父子进程 |
+| 资源复制 | 子进程获得父进程的副本（写时复制 COW 优化） |
+| 执行顺序 | 父子进程执行顺序不确定 |
+| 文件描述符 | 子进程继承父进程打开的文件描述符 |
+| 必须 exit | 子进程处理完后必须调用 `exit()` 终止 |
+
+---
+
+## 三、exec 族函数 -- 替换进程映像
+
+### 3.1 基本原理
+
+`exec` 族函数用一个新的程序**替换**当前进程的代码段、数据段和堆栈。进程的 PID 不变，但执行的代码完全改变。`exec` 调用成功后**不会返回**，只有出错时才返回 -1。
+
+```mermaid
+graph LR
+    A["当前进程<br/>PID=1234<br/>执行 myprogram"] -->|execvp("ps", args)| B["同一进程<br/>PID=1234<br/>执行 ps 命令"]
+    B --> C["原来的代码段<br/>被完全替换"]
+
+    style A fill:#e1f5fe
+    style B fill:#e8f5e9
+```
+
+### 3.2 exec 族函数对比
+
+| 函数 | 参数形式 | 路径搜索 | 环境变量 |
+|------|----------|----------|----------|
+| `execl(path, arg0, ..., NULL)` | 列表 | 完整路径 | 继承父进程 |
+| `execlp(file, arg0, ..., NULL)` | 列表 | 搜索 PATH | 继承父进程 |
+| `execle(path, arg0, ..., NULL, envp)` | 列表 | 完整路径 | 自定义 |
+| `execv(path, argv)` | 数组 | 完整路径 | 继承父进程 |
+| `execvp(file, argv)` | 数组 | 搜索 PATH | 继承父进程 |
+
+**记忆技巧**：
+- `l` = list（参数列表），`v` = vector（参数数组）
+- `p` = path（搜索 PATH 环境变量），`e` = environment（自定义环境变量）
+
+### 3.3 exec 示例
+
+参考 `实例源代码/chap5/exec1.c`：
+
+```c
+#include "wrapper.h"
+int main(void)
+{
+    char *arg[] = {"ps", "-o", "pid,ppid,pgrp,session,tpgid,comm", NULL};
+    execvp("ps", arg);       // 用 ps 命令替换当前进程
+    perror("exec ps");       // 如果 execvp 返回，说明出错
+    exit(1);
+}
+```
+
+**运行结果**：程序执行后变成了 `ps` 命令，显示当前系统的进程信息。
+
+### 3.4 fork + exec 组合
+
+在实际应用中，`fork()` 和 `exec()` 通常配合使用：
+
+```mermaid
+sequenceDiagram
+    participant 父进程
+    participant 子进程
+    participant 新程序
+
+    父进程->>子进程: fork()
+    Note over 子进程: 子进程是父进程的副本
+    子进程->>新程序: execvp("ls", args)
+    Note over 新程序: 子进程的代码被 ls 替换
+    新程序-->>父进程: 执行完毕
+    父进程->>父进程: wait() 回收子进程
+```
+
+这种模式是 shell 执行命令的核心机制：先 `fork` 创建子进程，再在子进程中 `exec` 执行新程序。
+
+---
+
+## 四、wait/waitpid -- 等待子进程
+
+### 4.1 为什么需要 wait
+
+父进程创建子进程后，需要等待子进程结束并回收其资源。如果不调用 `wait`，子进程终止后会变成**僵尸进程**（详见第六节）。
+
+### 4.2 wait 与 waitpid
+
+| 函数 | 说明 |
+|------|------|
+| `wait(&status)` | 等待任意一个子进程结束 |
+| `waitpid(pid, &status, options)` | 可指定等待的子进程 |
+| `WIFEXITED(status)` | 判断子进程是否正常退出 |
+| `WEXITSTATUS(status)` | 获取子进程的退出状态 |
+
+**waitpid 的 pid 参数**：
+- `pid > 0`：等待指定 PID 的子进程
+- `pid = -1`：等待任意子进程（等同于 `wait`）
+- `pid = 0`：等待同一进程组的任意子进程
+- `pid < -1`：等待进程组 ID 为 |pid| 的任意子进程
+
+### 4.3 waitpid 示例
+
+参考 `实例源代码/chap5/waitpid1.c`：
+
+```c
+#include "wrapper.h"
+#define N 2
+
+int main()
+{
+    int status, i;
+    pid_t pid;
+
+    // 父进程创建 N 个子进程
+    for (i = 0; i < 2; i++)
+        if ((pid = fork()) == 0)   // 子进程
+            exit(100 + i);         // 以不同状态退出
+
+    // 父进程按任意顺序等待所有子进程
+    while ((pid = waitpid(-1, &status, 0)) > 0) {
+        if (WIFEXITED(status))
+            printf("child %d terminated normally with exit status=%d\n",
+                   pid, WEXITSTATUS(status));
+        else
+            printf("child %d terminated abnormally\n", pid);
+    }
+
+    // 所有子进程已结束，waitpid 返回 -1，errno 为 ECHILD
+    if (errno != ECHILD)
+        perror("waitpid error");
+
+    exit(0);
+}
+```
+
+**输出示例**：
+```
+child 1235 terminated normally with exit status=100
+child 1236 terminated normally with exit status=101
+```
+
+---
+
+## 五、exit/_exit -- 进程终止
+
+### 5.1 两种终止方式
+
+| 函数 | 头文件 | 行为 |
+|------|--------|------|
+| `exit(status)` | `<stdlib.h>` | 执行清理工作（刷新缓冲区、调用 atexit 注册的函数），然后终止 |
+| `_exit(status)` | `<unistd.h>` | 立即终止，不执行任何清理 |
+
+### 5.2 exit 的清理过程
+
+```mermaid
+graph TD
+    A["调用 exit(status)"] --> B["执行 atexit() 注册的清理函数"]
+    B --> C["刷新 stdio 缓冲区<br/>（fclose 所有打开的流）"]
+    C --> D["调用 _exit(status)"]
+    D --> E["内核回收进程资源"]
+
+    style A fill:#e1f5fe
+    style E fill:#ffcdd2
+```
+
+### 5.3 退出状态
+
+参考 `实例源代码/chap5/exitstatus.c`：
+
+```c
+#include <stdlib.h>
+int main() { exit(100); }
+```
+
+父进程通过 `waitpid` 的 `WEXITSTATUS(status)` 宏获取子进程的退出状态值（0-255）。
+
+---
+
+## 六、僵尸进程
+
+### 6.1 什么是僵尸进程
+
+当子进程终止后，如果父进程没有调用 `wait()` 或 `waitpid()` 回收子进程的退出状态，子进程的进程控制块（PCB）仍然保留在系统中，成为**僵尸进程（Zombie Process）**。
+
+### 6.2 僵尸进程的产生
+
+参考 `实例源代码/chap5/zombie.c`：
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+int main()
+{
+    pid_t pid;
+    if ((pid = fork()) < 0) {
+        perror("fork failed");
+        exit(1);
+    } else if (pid == 0) {
+        printf("child...\n");    // 子进程打印后退出
+    } else {
+        printf("parent...\n");
+        while (1);               // 父进程不调用 wait()，子进程成为僵尸
+    }
+    return 0;
+}
+```
+
+### 6.3 僵尸进程的生命周期
+
+```mermaid
+sequenceDiagram
+    participant 父进程
+    participant 子进程
+    participant 操作系统内核
+
+    父进程->>子进程: fork() 创建子进程
+    子进程->>子进程: 执行任务
+    子进程->>操作系统内核: exit() 终止
+    操作系统内核->>父进程: 发送 SIGCHLD 信号
+    Note over 父进程: 父进程没有调用 wait()
+    Note over 操作系统内核: 子进程的 PCB 无法释放
+    Note over 操作系统内核: 子进程成为僵尸进程
+    Note over 操作系统内核: 僵尸进程占用 PID 资源
+```
+
+### 6.4 僵尸进程的危害与解决
+
+| 危害 | 说明 |
+|------|------|
+| 占用 PID | 僵尸进程的 PID 无法被复用 |
+| 资源泄漏 | 虽然不占内存，但 PCB 信息占用内核资源 |
+| 累积效应 | 大量僵尸进程可耗尽 PID 资源 |
+
+**解决方法**：
+1. 父进程调用 `wait()` 或 `waitpid()` 回收子进程
+2. 注册 `SIGCHLD` 信号处理函数，在其中调用 `waitpid()`
+3. 父进程先退出，让 init 进程（PID=1）自动回收孤儿进程
+
+---
+
+## 七、信号机制
+
+### 7.1 信号的概念
+
+信号是操作系统通知进程发生了某种事件的一种**异步通信机制**。进程可以注册信号处理函数来响应特定信号。
+
+```mermaid
+graph LR
+    SRC["信号来源"] --> SIG["信号"]
+    SIG --> PROC["目标进程"]
+
+    SRC --> S1["用户输入 Ctrl+C"]
+    SRC --> S2["kill 命令"]
+    SRC --> S3["子进程终止"]
+    SRC --> S4["定时器超时"]
+    SRC --> S5["非法内存访问"]
+
+    PROC --> H1["执行信号处理函数"]
+    PROC --> H2["忽略信号"]
+    PROC --> H3["执行默认动作"]
+
+    style SIG fill:#fff3e0
+    style SRC fill:#e1f5fe
+    style PROC fill:#e8f5e9
+```
+
+### 7.2 常见信号
+
+| 信号 | 编号 | 默认动作 | 说明 |
+|------|:----:|----------|------|
+| `SIGINT` | 2 | 终止 | 用户按 Ctrl+C |
+| `SIGKILL` | 9 | 终止 | 强制终止（**不可捕获**） |
+| `SIGTERM` | 15 | 终止 | 请求终止（可捕获） |
+| `SIGCHLD` | 17 | 忽略 | 子进程状态改变 |
+| `SIGALRM` | 14 | 终止 | 定时器超时 |
+| `SIGSEGV` | 11 | 终止+core | 段错误 |
+| `SIGSTOP` | 19 | 停止 | 暂停进程（**不可捕获**） |
+| `SIGCONT` | 18 | 继续 | 恢复被暂停的进程 |
+
+### 7.3 signal() 注册信号处理函数
+
+参考 `实例源代码/chap5/signal1.c`：
+
+```c
+#include "wrapper.h"
+
+void handler1(int sig)
+{
+    pid_t pid;
+    if ((pid = waitpid(-1, NULL, 0)) < 0)
+        perror("waitpid error");
+    printf("Handler reaped child %d\n", (int)pid);
+    sleep(2);
+    return;
+}
+
+int main()
+{
+    int i, n;
+    char buf[MAXBUF];
+
+    // 注册 SIGCHLD 信号处理函数
+    if (signal(SIGCHLD, handler1) == SIG_ERR)
+        perror("signal error");
+
+    // 父进程创建 3 个子进程
+    for (i = 0; i < 3; i++) {
+        if (fork() == 0) {
+            printf("Hello from child %d\n", (int)getpid());
+            sleep(1);
+            exit(0);
+        }
+    }
+
+    // 父进程等待终端输入
+    if ((n = read(STDIN_FILENO, buf, sizeof(buf))) < 0)
+        perror("read");
+
+    printf("Parent processing input\n");
+    while (1);
+    exit(0);
+}
+```
+
+**信号处理流程**：
+
+```mermaid
+sequenceDiagram
+    participant 父进程
+    participant 子进程1
+    participant 子进程2
+    participant 子进程3
+    participant 信号处理函数
+
+    父进程->>信号处理函数: signal(SIGCHLD, handler1)
+    父进程->>子进程1: fork()
+    父进程->>子进程2: fork()
+    父进程->>子进程3: fork()
+
+    子进程1->>父进程: exit() 触发 SIGCHLD
+    父进程->>信号处理函数: 调用 handler1()
+    信号处理函数->>信号处理函数: waitpid() 回收子进程
+
+    子进程2->>父进程: exit() 触发 SIGCHLD
+    父进程->>信号处理函数: 调用 handler1()
+    信号处理函数->>信号处理函数: waitpid() 回收子进程
+
+    子进程3->>父进程: exit() 触发 SIGCHLD
+    父进程->>信号处理函数: 调用 handler1()
+    信号处理函数->>信号处理函数: waitpid() 回收子进程
+```
+
+### 7.4 SIGALRM 定时器
+
+参考 `实例源代码/chap5/alarm.c`：
+
+```c
+#include "wrapper.h"
+
+void handler(int sig)
+{
+    static int beeps = 0;
+    printf("BEEP\n");
+    if (++beeps < 5)
+        alarm(1);    // 1秒后再次触发 SIGALRM
+    else {
+        printf("BOOM!\n");
+        exit(0);
+    }
+}
+
+int main()
+{
+    signal(SIGALRM, handler);  // 注册 SIGALRM 处理函数
+    alarm(1);                  // 1秒后触发第一次 SIGALRM
+    while (1);                 // 等待信号
+    exit(0);
+}
+```
+
+**输出**：每隔 1 秒打印一次 "BEEP"，第 5 次后打印 "BOOM!" 并退出。
+
+---
+
+## 八、Shell 的实现
+
+### 8.1 Shell 的工作原理
+
+Shell 是一个命令解释器，其核心逻辑可以用一个循环概括：
+
+```mermaid
+graph TD
+    A["打印提示符 %"] --> B["读取用户输入命令"]
+    B --> C{"命令是否为空?"}
+    C -->|是| A
+    C -->|否| D{"是否为内置命令?"}
+    D -->|是 exit| E["退出 shell"]
+    D -->|是其他| F["执行内置命令"]
+    F --> A
+    D -->|否| G["fork() 创建子进程"]
+    G --> H["子进程: execvp() 执行命令"]
+    G --> I["父进程: waitpid() 等待子进程"]
+    H --> A
+    I --> A
+
+    style A fill:#e1f5fe
+    style E fill:#ffcdd2
+    style G fill:#e8f5e9
+```
+
+### 8.2 shellex.c 核心实现
+
+参考 `实例源代码/chap5/shellex.c`，这是一个完整的简易 shell 实现：
+
+```c
+#include "wrapper.h"
+#define MAXARGS   128
+
+// 解析命令行，返回是否为后台作业
+int parseline(char *buf, char **argv)
+{
+    char *delim;
+    int argc;
+    int bg;
+
+    buf[strlen(buf)-1] = ' ';    // 用空格替换末尾换行
+    while (*buf && (*buf == ' ')) // 跳过前导空格
+        buf++;
+
+    argc = 0;
+    while ((delim = strchr(buf, ' '))) {
+        argv[argc++] = buf;
+        *delim = '\0';
+        buf = delim + 1;
+        while (*buf && (*buf == ' '))
+            buf++;
+    }
+    argv[argc] = NULL;
+
+    if (argc == 0) return 1;
+
+    // 检查是否应在后台执行（最后一个参数为 &）
+    if ((bg = (*argv[argc-1] == '&')) != 0)
+        argv[--argc] = NULL;
+    return bg;
+}
+
+// 执行命令
+void execute(char *cmdline)
+{
+    char *argv[MAXARGS];
+    char buf[MAXLINE];
+    int bg;
+    pid_t pid;
+
+    strcpy(buf, cmdline);
+    bg = parseline(buf, argv);
+    if (argv[0] == NULL) return;
+
+    if (!builtin_command(argv)) {
+        if ((pid = fork()) == 0) {           // 子进程
+            if (execvp(argv[0], argv) < 0) {
+                printf("%s: Command not found.\n", argv[0]);
+                exit(0);
+            }
+        }
+        if (!bg) {                            // 前台执行
+            int status;
+            if (waitpid(pid, &status, 0) < 0)
+                perror("waitpid error");
+        }
+        else                                  // 后台执行
+            printf("%d %s", pid, cmdline);
+    }
+    return;
+}
+
+// 判断内置命令（如 exit）
+int builtin_command(char **argv)
+{
+    if (!strcmp(argv[0], "exit"))
+        exit(0);
+    if (!strcmp(argv[0], "&"))
+        return 1;
+    return 0;
+}
+
+int main()
+{
+    char cmdline[MAXLINE];
+    while (1) {
+        printf("%% ");                     // 打印提示符
+        fgets(cmdline, MAXLINE, stdin);    // 读取命令
+        if (feof(stdin)) exit(0);
+        execute(cmdline);                  // 执行命令
+    }
+}
+```
+
+### 8.3 Shell 执行流程图
+
+```mermaid
+sequenceDiagram
+    participant 用户
+    participant Shell主进程
+    participant 子进程
+    participant 操作系统
+
+    loop Shell 主循环
+        用户->>Shell主进程: 输入 "ls -l"
+        Shell主进程->>Shell主进程: parseline() 解析命令
+        Shell主进程->>子进程: fork() 创建子进程
+        子进程->>操作系统: execvp("ls", ["ls", "-l", NULL])
+        Note over 操作系统: ls 程序替换子进程
+        操作系统-->>子进程: ls 执行完毕
+        子进程->>Shell主进程: exit()
+        Shell主进程->>Shell主进程: waitpid() 回收子进程
+        Shell主进程-->>用户: 显示结果，打印提示符
+    end
+```
+
+### 8.4 前台进程与后台进程
+
+- **前台进程**：Shell 调用 `waitpid()` 等待子进程结束后才继续接受输入
+- **后台进程**：Shell 不等待，直接打印子进程 PID 并继续接受输入（命令末尾加 `&`）
+
+### 8.5 管道与重定向
+
+实验中的 `task52.c` 实现了管道和重定向功能：
+
+**输出重定向**：使用 `dup2()` 将标准输出重定向到文件
+```c
+int fd = open("output.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
+dup2(fd, STDOUT_FILENO);  // 将 STDOUT 重定向到文件
+close(fd);
+execvp(args[0], args);    // 执行命令，输出写入文件
+```
+
+**管道**：使用 `pipe()` 创建管道，连接两个进程的输入输出
+```c
+int pipefd[2];
+pipe(pipefd);  // pipefd[0]=读端, pipefd[1]=写端
+
+// 子进程1: 写入管道
+dup2(pipefd[1], STDOUT_FILENO);
+close(pipefd[0]);
+execvp(cmd1_args[0], cmd1_args);
+
+// 子进程2: 从管道读取
+dup2(pipefd[0], STDIN_FILENO);
+close(pipefd[1]);
+execvp(cmd2_args[0], cmd2_args);
+```
+
+---
+
+## 九、Daemon 进程
+
+### 9.1 什么是 Daemon
+
+Daemon（守护进程）是在后台运行的特殊进程，通常在系统启动时创建，一直运行到系统关闭。常见的 daemon 有：`sshd`（SSH 服务）、`httpd`（Web 服务）、`crond`（定时任务）等。
+
+### 9.2 Daemon 的特点
+
+- 没有控制终端（不与任何终端关联）
+- 在后台运行
+- 父进程是 init（PID=1）
+- 通常以 `d` 结尾命名
+
+### 9.3 创建 Daemon 的五步法
+
+参考 `实例源代码/chap5/daemon.c`：
+
+```c
+int init_daemon(void)
+{
+    pid_t pid;
+    int i;
+
+    // 第1步：fork() + 父进程退出，脱离终端控制
+    pid = fork();
+    if (pid == -1) return -1;
+    else if (pid != 0) exit(EXIT_SUCCESS);
+
+    // 第2步：setsid() 创建新会话，成为会话首进程
+    if (setsid() == -1) return -1;
+
+    // 第3步：(可选) 再次 fork()，确保不会重新获得控制终端
+    // daemon.c 中省略了这一步，但 task53.c 中包含
+
+    // 第4步：chdir("/") 避免占用可卸载的文件系统
+    if (chdir("/") == -1) return -1;
+
+    // 第5步：关闭所有打开的文件描述符，重定向 0/1/2 到 /dev/null
+    for (i = 0; i < NR_OPEN; i++) close(i);
+    open("/dev/null", O_RDWR);  // stdin  -> /dev/null
+    dup(0);                      // stdout -> /dev/null
+    dup(0);                      // stderr -> /dev/null
+    return 0;
+}
+```
+
+**五步法流程图**：
+
+```mermaid
+graph TD
+    A["第1步: fork() + 父进程 exit()"] --> B["子进程成为孤儿进程<br/>被 init 收养"]
+    B --> C["第2步: setsid()"]
+    C --> D["创建新会话<br/>成为会话首进程<br/>脱离控制终端"]
+    D --> E["第3步: fork() + 父进程 exit()"]
+    E --> F["确保不会重新获得<br/>控制终端"]
+    F --> G["第4步: chdir('/')"]
+    G --> H["避免占用可卸载的<br/>文件系统"]
+    H --> I["第5步: 关闭 0/1/2<br/>重定向到 /dev/null"]
+    I --> J["Daemon 创建完成<br/>在后台运行"]
+
+    style A fill:#e1f5fe
+    style J fill:#e8f5e9
+```
+
+### 9.4 Daemon 文件监控实例
+
+实验中的 `task53.c` 实现了一个 daemon 文件监控程序：
+1. 创建守护进程
+2. 每隔 5 分钟读取目标文件内容，计算 hash 值
+3. 与上一次的 hash 值对比
+4. 如果文件被篡改，将事件记录到日志文件
+
+---
+
+## 十、实验任务概览
+
+本讲对应 [[实验02_进程控制]]，包含以下任务：
+
+| 任务 | 文件 | 内容 | 核心知识点 |
+|------|------|------|------------|
+| 任务一 | task51.c | 创建进程族亲结构（p1 -> p11, p12 -> p121, p122） | fork() + wait() + 进程树 |
+| 任务二 | task52.c | 简单 shell 实现（命令解析、重定向、管道） | fork() + exec() + dup2() + pipe() |
+| 任务三 | task53.c | daemon 文件监控（hash 值检测篡改） | daemon 五步法 + 文件 I/O |
+| 任务四 | task54.c | 信号机制管理子进程（create/kill/ps/exit） | signal() + kill() + SIGCHLD |
+
+---
+
+## 知识关联
+
+- 进程状态转换在处理机调度中有更详细的讨论，参见相关课件
+- 信号机制与进程间通信密切相关，参见 [[08_进程间通信]]
+- Shell 的并发版本（多进程并发服务器）在网络编程中会深入讨论
+- 线程可以看作轻量级进程，参见 [[07_多线程编程]]
+
+---
+
+## 思考题
+
+1. **fork 返回值的设计**：为什么 `fork()` 要返回两次而不是只返回一次？如果子进程不知道自己的 PID，可以用什么方式获取？
+2. **exec 的不可逆性**：为什么 `exec()` 成功后不返回？如果 `exec()` 执行失败会怎样？
+3. **僵尸进程的危害**：如果一个服务器程序不断创建子进程但从不 `wait`，最终会怎样？如何用 `SIGCHLD` 信号处理函数避免僵尸进程？
+4. **shell 的本质**：shell 执行 `ls -l` 命令时，为什么需要 `fork()` + `exec()` 两个步骤？只用 `exec()` 行不行？
+5. **daemon 的双重 fork**：为什么 daemon 创建通常要 `fork()` 两次？只 `fork()` 一次有什么问题？
+
+---
+
+## 扩展阅读
+
+- 《UNIX环境高级编程》第8章：进程控制
+- 《深入理解计算机系统》第8章：异常控制流
+- 《Linux/UNIX系统编程手册》第24-27章：进程的创建、终止、监控