# 第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章：进程的创建、终止、监控