1一句话 + 关键问题

一句话：UNIX 用一对奇特的系统调用创建进程——fork() 复制出一个几乎一模一样的子进程，exec() 让它变身为另一个程序；wait() 让父进程等子进程结束。

第 4 章说任何 OS 都要提供"创建、销毁、等待、其他控制、状态"这几类进程 API。本章是一段插叙（interlude），专讲 UNIX 的真实接口，偏重实践。你会看到：把"创建"拆成 fork 和 exec 两步看似古怪，却恰恰让 shell 能轻松实现重定向和管道。本章的文件描述符概念会在第 39 章（文件和目录）再次登场。

2核心概念速览

3fork()：调用一次，返回两次

原书图 5.1 的 p1.c：

int main(int argc, char *argv[]) {
    printf("hello (pid:%d)\n", (int) getpid());
    int rc = fork();
    if (rc < 0) {            // fork 失败
        fprintf(stderr, "fork failed\n");
        exit(1);
    } else if (rc == 0) {    // 子进程（新进程）
        printf("child (pid:%d)\n", (int) getpid());
    } else {                 // 父进程走这条路
        printf("parent of %d (pid:%d)\n", rc, (int) getpid());
    }
    return 0;
}

prompt> ./p1
hello (pid:29146)
parent of 29147 (pid:29146)
child (pid:29147)
prompt>

进程先打印 hello，带上自己的 PID 29146。然后调用 fork()——OS 创建一个新进程，它是调用进程的（几乎）精确副本。在 OS 看来，现在有两份 p1 在运行，而且两者都即将从 fork() 返回。新创建的子进程（child）不从 main() 开始（所以 hello 只打印了一次），而是像它自己调用了 fork() 一样"出生"。

还有一点：p1 的输出不是确定的（not deterministic）。子进程创建后，系统里有两个我们关心的活跃进程。假设只有一个 CPU，此刻父进程和子进程都可能先运行；上面是父进程先打印，另一次运行可能是：

prompt> ./p1
hello (pid:29146)
child (pid:29147)
parent of 29147 (pid:29146)
prompt>

决定此刻运行谁的是 CPU 调度器（scheduler）。调度器很复杂，我们通常不能对它的选择做强假设。这种不确定性（non-determinism）在多线程程序中会引出许多有趣的问题（第 26 章起）。

4wait()：让父进程等一等

有时父进程需要等子进程把事情做完。wait()（或更完整的 waitpid()）就是干这个的。原书图 5.2 的 p2.c 只是在父进程分支里加了一行：

    } else {                        // 父进程
        int rc_wait = wait(NULL);   // 阻塞，直到某个子进程结束；返回该子进程的 PID
        printf("parent of %d (rc_wait:%d) (pid:%d)\n", rc, rc_wait, (int) getpid());
    }

prompt> ./p2
hello (pid:29266)
child (pid:29267)
parent of 29267 (rc_wait:29267) (pid:29266)
prompt>

现在输出是确定的：子进程总是先打印。为什么？如果子进程先运行，它自然先打印；如果父进程先运行，它会立即调用 wait()，这个系统调用在子进程运行完并退出之前不会返回——所以即使父进程先运行，它也会礼貌地等子进程结束，然后才打印。（原书脚注提醒：有少数情况 wait() 会在子进程退出前返回，详见 man page；也要警惕书中"总是""绝对"之类的断言。）在上面的模拟器里选 p2 再点"枚举所有可能的输出"验证这一点。

5exec()：变身为另一个程序

只有 fork 的话，只能运行同一个程序的多个副本。想运行不同的程序，就要用 exec()（Linux 上有六个变体：execl()、execlp()、execle()、execv()、execvp()、execvpe()）。原书图 5.3 的 p3.c 让子进程运行字数统计程序 wc：

    } else if (rc == 0) {                  // 子进程
        printf("child (pid:%d)\n", (int) getpid());
        char *myargs[3];
        myargs[0] = strdup("wc");          // 程序名："wc"
        myargs[1] = strdup("p3.c");        // 参数：要统计的文件
        myargs[2] = NULL;                  // 数组结束标记
        execvp(myargs[0], myargs);         // 运行 wc
        printf("this shouldn't print out");
    } else { ... wait(NULL) ... }

prompt> ./p3
hello (pid:29383)
child (pid:29384)
29 107 1030 p3.c
parent of 29384 (rc_wait:29384) (pid:29383)
prompt>

exec 之后，就好像 p3.c 从来没有运行过一样；成功的 exec() 永远不会返回，所以 "this shouldn't print out" 永远不会被打印。

6为什么要这样设计：shell、重定向与管道

为什么把"创建新进程"这件简单的事拆成 fork 和 exec 这么古怪的两步？因为这样 shell 就能在 fork 之后、exec 之前运行一段代码，改变即将运行的程序的环境，从而轻松实现许多有趣的功能。

例如 wc p3.c > newfile.txt：wc 的输出被重定向（redirect）到文件 newfile.txt。shell 的做法很简单：子进程创建后、调用 exec() 之前，关闭标准输出，然后打开 newfile.txt。这样一来，即将运行的 wc 的所有输出都进了文件而不是屏幕（打开的文件描述符在 exec() 后保持打开）。

它之所以奏效，依赖于 OS 管理文件描述符的一个约定：UNIX 从 0 开始寻找空闲的文件描述符。关掉 STDOUT_FILENO（即 1）之后，它就是最小的空闲描述符，open() 必然分到它。此后子进程往标准输出写（如 printf()），就被透明地送进新文件。下面的模拟器逐步展示每个进程的文件描述符表如何变化：

原书图 5.4 的 p4.c 就是用代码实现同样的事：

    } else if (rc == 0) {
        // 子进程：把标准输出重定向到文件
        close(STDOUT_FILENO);
        open("./p4.output", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
        // 现在 exec "wc"……
        char *myargs[3];
        myargs[0] = strdup("wc");     // 程序：wc
        myargs[1] = strdup("p4.c");   // 参数：要统计的文件
        myargs[2] = NULL;
        execvp(myargs[0], myargs);
    } else {
        int rc_wait = wait(NULL);
    }

prompt> ./p4
prompt> cat p4.output
32 109 846 p4.c
prompt>

运行 p4 时看起来什么都没发生——shell 直接打印了提示符。其实 p4 确实 fork 了子进程、通过 execvp() 运行了 wc，只是输出被重定向到了 p4.output，所以屏幕上什么也没有；cat 一下就能看到结果。

UNIX 管道（pipe）的实现方式类似，只是用 pipe() 系统调用：一个进程的输出连到内核中的一个管道（即队列），另一个进程的输入连到同一个管道。于是一个进程的输出无缝地成为下一个的输入，长长的命令链就能串起来。例如在文件中找一个单词并数它出现了几次：grep -o foo file | wc -l。

7进程控制、信号与用户

除了 fork、exec、wait，UNIX 还有许多与进程交互的接口。kill() 系统调用向进程发送信号（signal），包括暂停、终止等各种指令。多数 shell 把某些按键组合配置成向前台进程发送特定信号：

谁可以给谁发信号？如果任何人都能随意向别人的进程发 SIGINT，系统的可用性和安全性就完了。所以现代系统有很强的用户（user）概念：用户输入密码登录后，可以启动进程并完全控制自己的进程；OS 负责把 CPU、内存、磁盘等资源分给各个用户及其进程。

实用工具：ps 查看正在运行的进程；top 显示进程及其资源占用（它常常声称自己就是头号资源大户）；kill、killall 发信号；各种 CPU 负载监视器让你一眼看出系统有多忙。还有一条：RTFM——读 man page（手册页）。关于 shell 和各个系统调用的返回值、错误条件，man page 里藏着大量有用的细节。

8进程树：fork.py 网页版

每次 fork 都在"家族树"上加一个孩子。原书作业用 fork.py 模拟一串动作：a+b 表示进程 a fork 出 b，c- 表示进程 c 退出。当一个进程退出时，它的孩子成了孤儿（orphan），会被过继给别人：默认过继给根进程 a（相当于 UNIX 的 init）；用 -R 时过继给退出进程自己的父进程（"本地过继"）。

9先预测，再验证

10动手实验

cd labs/05-process-api && make
./p1; ./p2; ./p3
make redirect   # ./p4 && cat p4.output
make order      # 跑 20 次 p1，统计 fork 后谁先打印
make buffer     # ./p1 | cat —— hello 为什么出现两次？
./var           # 作业 1：fork 后变量各自独立
./sharedfd      # 作业 2：父子共享打开的文件（及偏移量）
./pipe          # 作业 8：用 pipe() 把两个孩子连成 ls -1 / | wc -l

$ ./p3
hello (pid:344568)
child (pid:344569)
  29  130 1176 p3.c
parent of 344569 (rc_wait:344569) (pid:344568)
$ make redirect
  32  138 1083 p4.c
$ make order
      1 child
     19 parent
$ make buffer
hello (pid:344440)
parent of 344442 (pid:344440)
hello (pid:344440)
child (pid:344442)
$ ./var
fork 前: x=100  *heap=100  &x=0x7ffe83774710  heap=0x5d82f3f722a0
child : x=101  *heap=101  &x=0x7ffe83774710  heap=0x5d82f3f722a0
parent: x=99   *heap=99   &x=0x7ffe83774710  heap=0x5d82f3f722a0
$ ./sharedfd && cat shared.txt
偏移量 lseek(fd,0,SEEK_CUR) = 140（= 10 行的总字节数，说明父子共用一个偏移量）
parent line 0
parent line 1
child  line 0
parent line 2
child  line 1
...

11自测题

12常见误区与本章小结