1. 先搞懂课堂练习3.2到底在考什么

在头歌操作系统这门课的课堂练习里，3.2 进程的创建往往是很多人第一次真正和内核打照面的地方。它看起来只是写几行fork，但背后牵着进程控制块、地址空间复制、父子关系、调度时机和回收机制。这个练习的目标很直接：让你亲手创建进程、拿到进程号、观察父子关系，并理解fork、exec、wait这一套组合拳。适合正在做头歌操作系统课堂练习、准备操作系统期末复习、或者想从零开始手搓操作系统进程管理的同学。我会从题目常考形态、系统调用细节、可复现代码、常见报错排查几个角度，把进程创建这件事拆开讲，尽量让你在评测机上少卡几个晚上。

1.1 题目常见形态与评测逻辑

课堂练习 3.2 的题面通常不会写得特别复杂，常见要求有几种：一是调用fork创建一个子进程，分别打印父进程和子进程的pid；二是创建指定数量的子进程，让它们按某种顺序输出；三是用exec族函数让子进程去执行另一个程序；四是结合wait或waitpid观察僵尸进程与回收过程。评测逻辑一般不是看你代码写得多花哨，而是看输出是否匹配预期、进程数量是否正确、有没有产生多余进程、有没有出现死锁或无限创建。

这里有个很容易被忽略的点：头歌的评测环境通常是 Linux 容器或轻量虚拟机，进程号、调度顺序、输出缓冲行为都可能和你的本地 Ubuntu 不完全一样。所以你不能死记“父进程一定先打印”或者“子进程 pid 一定是 1234”。你要写的是逻辑正确的代码，让输出内容稳定，而不是依赖某个固定 pid。凡是题面要求打印 pid 的地方，通常评测脚本会用正则或变量替换去匹配，而不是比较具体数字。

另外，很多题目的隐藏要求是“不要创建多余进程”。比如让你创建 3 个子进程，你如果用循环fork却没有在子进程里及时break或exit，最后可能变成 8 个甚至更多进程。评测器一看到多出来的输出，直接判错。所以做这类题，第一步不是写代码，而是先画进程树：谁创建谁，哪个进程继续循环，哪个进程退出。

1.2 进程创建在操作系统课程里的位置

进程创建是操作系统课程里承上启下的知识点。往前看，它依赖进程的基本概念：程序、进程、PCB、进程状态、进程队列。往后看，它直接连接到进程调度、进程同步、进程通信、内存管理和文件系统。你如果在 3.2 这一关把fork的返回值、父子进程地址空间关系、exec替换过程搞明白，后面学wait、信号、管道、共享内存都会顺很多。

从内核视角看，创建进程不是“复制一份代码”这么简单。Linux 里fork会为子进程创建新的任务结构，分配新的 pid，复制父进程的页表，但为了性能并不会立刻复制全部物理内存，而是采用写时复制。也就是说，父子进程一开始共享同一份物理页，只有某一方尝试写入时，内核才复制出新的页。这个机制让fork看起来开销不大，但如果你在子进程里立刻修改大量全局变量，开销就会立刻显现。

课程练习往往不会让你去改内核，但会让你观察现象。比如父子进程同时修改一个全局变量，结果互不影响；父子进程同时打印，顺序不确定；父进程先退出，子进程变成孤儿进程。这些现象背后都是进程创建机制在起作用。你把这些现象解释清楚，实验报告就不愁写，面试被问到fork也能答出层次。

1.3 头歌环境与本地环境差异

头歌的在线环境一般会给你一个 Linux shell 和代码编辑区，可能已经预装gcc、make、gdb、strace、pstree等工具，也可能只给最基础的编译环境。你在本地调试时，习惯用Ctrl+C结束程序、用ps aux看进程，但在头歌里要留意权限限制：有些容器不允许你创建太多进程，有些命令没有安装，有些目录不可写。最稳妥的办法是先写一个最小可运行程序，确认编译和运行链路通了，再逐步加功能。

本地环境则宽松得多。你可以用 Ubuntu、Debian、CentOS 或者 WSL，装好gcc和procps包，随时用ps -ef --forest看进程树。我建议本地和头歌两边都跑一遍：本地用来理解现象，头歌用来适配评测。因为本地可能出现“父进程先输出”，头歌却“子进程先输出”，这不是你代码错了，而是调度和缓冲差异。遇到这种情况，优先检查输出格式是否严格，其次检查是否用了fflush(stdout)或setbuf(stdout, NULL)，再考虑是否需要wait来强制顺序。

还有一个实际差异：头歌评测可能对标准输出和标准错误分开处理。你如果用了perror或fprintf(stderr, ...)，错误信息可能不会出现在评测输出里，但也可能干扰判题。所以正式提交前，把调试输出删掉，只保留题目要求的打印内容。这个习惯在以后做工程时同样重要：日志可以帮你排查，但不能混进接口返回里。

2. 进程创建核心系统调用拆解

2.1 fork：一次调用两次返回

fork是进程创建的核心。它的函数原型是pid_t fork(void);，调用一次，成功时会在父进程中返回子进程的 pid，在子进程中返回 0，失败时返回 -1 并设置errno。很多初学者觉得“一次调用两次返回”很绕，其实你可以把它想成分叉路口：父进程走到fork后，内核复制出一个子进程，父子进程都从fork后面继续执行，只是各自拿到的返回值不同。父进程拿到的是“我孩子的身份证号”，子进程拿到的是 0，表示“我就是孩子”。

正因为返回值不同，代码里最常见的分流写法就是：

pid_t pid = fork(); if (pid < 0) { perror("fork"); return 1; } else if (pid == 0) { // 子进程分支 } else { // 父进程分支 }

这段代码看起来简单，但有两个坑。第一，fork失败必须处理，不能默认它永远成功。第二，父子进程的执行顺序不确定，谁先谁后由调度器决定，不能靠代码顺序推断。如果你需要父进程等子进程，必须用wait或waitpid，不能靠sleep撞运气。sleep只能用于观察实验，不能用于生产逻辑。

还有一个细节：fork之后，子进程会继承父进程的文件描述符、信号处理方式、当前工作目录、环境变量等，但不会继承父进程的 pid、父进程的未决信号和定时器。理解“继承什么、不继承什么”，对后面做重定向、管道、守护进程非常关键。课堂练习 3.2 虽然只考创建，但你多知道一点，后面做综合实验会轻松很多。

2.2 exec族：不创建进程也能换程序

exec族函数不创建新进程，而是把当前进程的用户空间代码和数据替换成另一个程序的。也就是说，fork负责“生”，exec负责“换魂”。典型组合是：父进程fork出子进程，子进程调用exec执行新程序，父进程继续做自己的事。Linux shell 执行外部命令时基本就是这个套路：shell 先fork，子进程exec命令，父进程wait子进程结束。

exec族有多个成员，常用的是execl、execv、execlp、execvp。区别主要在参数传递方式和是否搜索PATH。execl和execv需要你写完整路径；execlp和execvp带p，会去PATH环境变量里找可执行文件。参数列表最后必须用NULL结尾，这个NULL不是可选项，忘了就会读到非法内存，程序可能崩溃或执行奇怪的东西。

#include <unistd.h> #include <stdio.h> int main() { printf("before exec\n"); execlp("ls", "ls", "-l", NULL); perror("exec failed"); return 1; }

注意：exec成功时不会返回，它直接替换掉当前程序；只有失败才会返回 -1。所以perror写在exec后面，不是“执行完 ls 再报错”，而是“如果 exec 没成功，才走到这里”。这个逻辑和普通函数调用完全不同，初学时要特别小心。课堂练习里如果要求子进程执行ls、pwd、echo之类命令，你要确保参数列表正确，并且父进程要回收子进程，否则可能留下僵尸。

2.3 wait/waitpid：回收子进程

子进程结束后，并不会立刻从系统里消失。它会变成一个僵尸进程，保留退出状态等信息，等待父进程读取。父进程调用wait或waitpid后，内核才会释放子进程的 PCB。如果父进程一直不回收，僵尸进程就会堆积，虽然单个僵尸占用资源不多，但数量多了会耗尽 pid 或进程表项。课堂练习里经常要求“父进程等待所有子进程结束”，就是为了让你养成回收习惯。

wait原型是pid_t wait(int *status);，它会阻塞等待任意一个子进程结束，并返回该子进程 pid。waitpid更灵活：pid_t waitpid(pid_t pid, int *status, int options);，可以指定等待哪个子进程，也可以设置WNOHANG非阻塞轮询。最常用的状态检查宏有WIFEXITED(status)判断是否正常退出，WEXITSTATUS(status)获取退出码，WIFSIGNALED(status)判断是否被信号终止。

#include <sys/wait.h> #include <unistd.h> #include <stdio.h> int main() { pid_t pid = fork(); if (pid == 0) { printf("child running\n"); _exit(0); } else if (pid > 0) { int status; waitpid(pid, &status, 0); if (WIFEXITED(status)) { printf("child exit code: %d\n", WEXITSTATUS(status)); } } return 0; }

这里我特意用了_exit(0)而不是exit(0)。在fork之后的子进程里，exit会刷新 stdio 缓冲区，可能导致父进程缓冲区里的内容被重复打印。_exit是直接进入内核退出，不刷新用户态缓冲区。这个区别在做输出匹配的题目里非常关键，后面还会专门讲。

2.4 getpid/getppid：进程身份证

getpid()返回当前进程 pid，getppid()返回父进程 pid。它们通常和fork一起出现，用来验证父子关系。比如子进程打印getpid()和getppid()，父进程打印getpid()和fork返回的子进程 pid，两边一对照，就能看出谁是谁。注意：父进程的getpid()和子进程的getppid()应该相等，但这是在你没有孤儿进程的情况下。如果父进程先退出，子进程的getppid()会变成 1 或其他收养进程的 pid。

进程号是动态分配的，不要写死。头歌评测时，你的程序可能被反复运行，每次 pid 都不同。所以输出里可以有 pid，但你要确保格式清晰，比如parent pid: 1234, child pid: 1235。如果题面只要求打印 pid，不要加额外文字，否则可能匹配失败。我一般会先看题面示例输出，严格按示例格式来，示例里有什么标点、空格、换行，我都尽量保持一致。

getpid还有一个实用场景：生成临时文件名。以前写多进程程序时，如果多个进程同时写同一个临时文件，很容易冲突。用getpid()拼进文件名，比如tmp_%d.log，就能避免互相覆盖。这个技巧虽然不属于 3.2 的核心考点，但在后面做进程通信、文件锁实验时很有用。

3. 从零写一个可复现的进程创建程序

3.1 基础版fork与编译运行

先写一个最小版本，确认fork的基本行为。代码里包含头文件、错误处理、父子分流。编译时用gcc -Wall -o fork_demo fork_demo.c，-Wall打开警告，能帮你发现未使用变量、隐式声明等问题。运行后多跑几次，观察输出顺序是否变化。

#include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> int main() { pid_t pid = fork(); if (pid < 0) { perror("fork failed"); return 1; } if (pid == 0) { printf("child: pid=%d, ppid=%d\n", getpid(), getppid()); _exit(0); } else { printf("parent: pid=%d, child_pid=%d\n", getpid(), pid); wait(NULL); } return 0; }

这段代码的逻辑是：父进程打印自己的 pid 和fork返回的子进程 pid，然后wait(NULL)等待子进程结束；子进程打印自己的 pid 和父进程 pid，然后_exit(0)。父子进程的输出顺序可能相反，这很正常。如果你想让父进程一定在子进程之后打印，可以把父进程的printf放到wait后面，但那样父子关系看起来就不那么直观。课堂练习一般只要求打印内容正确，不要求严格顺序。

实测下来，头歌环境里wait(NULL)非常稳。它保证父进程不会提前退出，也就不会产生孤儿进程。很多同学写代码时忘了wait，结果子进程还在运行，父进程已经结束，评测器可能认为程序提前退出，或者输出还没刷完。加一个wait兜底，能避免很多玄学问题。

3.2 加入wait的稳定版本

基础版已经用了wait，但真实题目往往要求创建多个子进程，并且每个子进程做不同的事。这时候需要更精细的回收。wait(NULL)只等待任意一个子进程，如果有多个子进程，调用一次只回收一个。要回收全部，可以在循环里调用，或者用waitpid指定 pid。下面这个版本创建 3 个子进程，每个子进程打印自己的编号，父进程依次回收。

#include <stdio.h> #include <unistd.h> #include <sys/wait.h> #include <stdlib.h> int main() { pid_t pids[3]; for (int i = 0; i < 3; i++) { pids[i] = fork(); if (pids[i] < 0) { perror("fork"); exit(1); } if (pids[i] == 0) { printf("child %d: pid=%d, ppid=%d\n", i, getpid(), getppid()); _exit(0); } } for (int i = 0; i < 3; i++) { int status; pid_t done = waitpid(pids[i], &status, 0); if (done > 0 && WIFEXITED(status)) { printf("parent: child %d exited with %d\n", i, WEXITSTATUS(status)); } } return 0; }

关键点在if (pids[i] == 0)里面必须_exit(0)。如果只写break，子进程会跳出循环继续执行后面的父进程回收逻辑，虽然不会继续fork，但会干扰父进程的waitpid。如果写return 0，效果和_exit类似，但return会触发热 stdio 刷新，可能重复输出。最保险的还是_exit(0)。另外，父进程保存了每个子进程的 pid，所以可以用waitpid按顺序回收，输出顺序更可控。

如果你在头歌遇到“输出顺序与示例不一致”，可以把父进程的回收输出和子进程的输出分开，先让子进程全部结束，再统一打印汇总。这样评测器看到的子进程输出顺序仍然可能变化，但汇总顺序稳定。具体怎么改，要看题面允不允许调整。不要为了顺序而用sleep硬等，sleep在不同环境表现不同，而且浪费评测时间。

3.3 创建多个子进程的循环写法

循环fork是课堂练习最容易翻车的地方。核心原则：每个子进程在完成自己的任务后必须立即退出，不能继续参与下一次循环。很多错误代码长这样：

for (int i = 0; i < 3; i++) { fork(); printf("hello\n"); }

这段代码会打印 8 次hello，因为每次fork都让当前所有进程数量翻倍。第一次循环后 2 个进程，第二次 4 个，第三次 8 个。每个进程都会继续循环，子进程又生孙子进程，最后形成进程树。课堂练习如果要求“创建 3 个子进程”，这么写就错了，因为实际创建了 7 个子进程，加上父进程一共 8 个。

正确的写法是子进程立即_exit，父进程继续循环：

for (int i = 0; i < 3; i++) { pid_t pid = fork(); if (pid == 0) { printf("child %d: pid=%d\n", i, getpid()); _exit(0); } else if (pid > 0) { // 父进程继续下一次循环 } else { perror("fork"); exit(1); } }

这样父进程创建 3 个子进程，子进程各自打印后退出，总进程数就是 4 个（1 父 + 3 子）。如果你需要子进程之间有一定的执行时间，可以在子进程里加sleep(1)，但父进程仍然要用wait回收，不能直接退出。加sleep只是为了观察进程状态，不是正确性依赖。

还有一点：循环变量i在fork后会被父子进程各自复制一份。子进程看到的i是fork那一刻的值，父进程继续递增。所以子进程打印的编号通常是正确的。但如果你在子进程里修改i，父进程不受影响。这个特性可以用来区分父子进程，但不能用来通信。

3.4 用exec执行外部命令

题目如果要求子进程执行ls、pwd、echo、date等命令，就要用exec。最简写法是在子进程分支里调用execlp或execvp。比如子进程执行ls -l：

#include <stdio.h> #include <unistd.h> #include <sys/wait.h> int main() { pid_t pid = fork(); if (pid < 0) { perror("fork"); return 1; } if (pid == 0) { execlp("ls", "ls", "-l", NULL); perror("execlp"); _exit(1); } else { wait(NULL); printf("parent done\n"); } return 0; }

注意execlp的第一个参数是文件名，第二个参数开始是argv[0]、argv[1]……最后必须是NULL。argv[0]通常和文件名一致，但不强制。执行ls时，argv[0]写"ls"，argv[1]写"-l"。如果你要执行echo hello，可以写execlp("echo", "echo", "hello", NULL);。如果exec失败，后面的perror会打印错误原因，然后_exit(1)确保子进程不会继续执行父进程代码。

有些题面要求子进程执行/bin/ls，那就要用execl("/bin/ls", "ls", "-l", NULL);。带p的版本会搜索PATH，不带p的版本必须写绝对路径或相对路径。头歌环境里PATH通常是标准配置，execlp("ls", ...)一般没问题。如果评测报“No such file or directory”，先检查命令名是否拼错，再检查是否需要绝对路径。

4. 进程树、状态与关键实验

4.1 用ps和pstree观察进程树

写代码是一回事，观察进程是另一回事。做 3.2 练习时，我强烈建议你开两个终端：一个运行程序，一个用ps或pstree看进程关系。常用命令有：

ps -ef --forest | grep fork_demo pstree -p | grep fork_demo ps -o pid,ppid,stat,cmd -C fork_demo

ps -ef --forest会用树形结构显示父子关系，pstree -p会把 pid 标在进程名旁边。如果程序里有sleep，你就能在另一个终端里看到进程状态S（可中断睡眠）、R（运行）、Z（僵尸）等。僵尸进程会显示为<defunct>，父进程 pid 还在，说明还没回收。孤儿进程的父 pid 会变成 1，或者变成某个收养进程。

头歌环境不一定有pstree，如果没有，就用ps -ef配合grep。你还可以在代码里打印getpid()和getppid()，然后和ps输出对照。这个对照过程能帮你真正理解“父子关系不是猜出来的，是内核记录的”。实验报告里如果放一张进程树截图，再配上代码输出，说服力会强很多。

4.2 僵尸进程实验

僵尸进程是子进程已退出但父进程还没回收的状态。制造僵尸很简单：子进程_exit(0)，父进程不调用wait，而是sleep(30)。在这 30 秒内，子进程就是僵尸。

#include <stdio.h> #include <unistd.h> #include <stdlib.h> int main() { pid_t pid = fork(); if (pid == 0) { printf("child exited\n"); _exit(0); } else if (pid > 0) { printf("parent sleeping, child pid=%d\n", pid); sleep(30); wait(NULL); printf("parent collected child\n"); } return 0; }

运行后立刻用ps -o pid,ppid,stat,cmd -C a.out或ps -ef | grep defunct观察，你会看到子进程状态是Z，命令名后面带<defunct>。等父进程sleep结束调用wait后，僵尸才消失。这个实验说明：子进程退出后不会自动消失，父进程有责任回收。课堂练习里如果问“为什么要wait”，你就用这个现象回答。

注意：僵尸进程不能被kill -9杀死，因为它已经死了，只是在等父进程读取状态。真正能清理它的是父进程调用wait，或者父进程退出后被收养进程回收。所以不要试图用kill解决僵尸，那只会让你更困惑。

4.3 孤儿进程实验

孤儿进程是父进程先退出，子进程还在运行。父进程退出后，子进程会被某个收养进程接管，通常是 pid 为 1 的 init 或 systemd，在容器环境里可能是其他 pid。子进程的getppid()会变成收养进程的 pid。

#include <stdio.h> #include <unistd.h> #include <stdlib.h> int main() { pid_t pid = fork(); if (pid == 0) { printf("child before sleep: ppid=%d\n", getppid()); sleep(5); printf("child after sleep: ppid=%d\n", getppid()); _exit(0); } else if (pid > 0) { printf("parent exiting, child pid=%d\n", pid); _exit(0); } return 0; }

父进程直接_exit(0)，子进程睡 5 秒。你会在子进程第二次打印时看到ppid变了。这个实验说明父子关系不是永久的，父进程退出后，子进程会被重新收养。孤儿进程和僵尸进程是两种相反的状态：孤儿是父先走，子还活着；僵尸是子先走，父不回收。把这两个实验做一遍，进程生命周期就基本清楚了。

4.4 fork与缓冲区导致输出重复

这是课堂练习里最经典的坑之一。看下面代码：

#include <stdio.h> #include <unistd.h> int main() { printf("hello"); fork(); return 0; }

如果标准输出是行缓冲或全缓冲，printf("hello")没有换行，内容可能还留在用户态缓冲区里。fork会复制整个进程地址空间，包括这个缓冲区。父子进程各自退出时刷新缓冲区，于是hello被打印两次。如果你写的是printf("hello\n");，终端是行缓冲，换行会触发刷新，fork前缓冲区已经空了，就不会重复。但如果输出被重定向到文件，标准输出变成全缓冲，即使有换行也可能留在缓冲区里，仍然可能重复。

解决办法有三个：第一，在fork前调用fflush(stdout);；第二，在fork前设置setbuf(stdout, NULL);关闭缓冲；第三，子进程用_exit而不是exit，避免刷新继承来的缓冲区。我在头歌做输出匹配题时，通常会直接在main开头加setbuf(stdout, NULL);，这样所有打印立即输出，顺序也更接近代码执行顺序，排查问题方便很多。

注意：setbuf(stdout, NULL)会降低输出性能，但在课堂练习这种小规模程序里完全可接受。不要在生产环境随便关闭缓冲。

5. 参数计算与经典陷阱

5.1 循环fork的进程数量计算

循环fork的进程数量是必考计算题。规则很简单：如果循环n次，每次fork后父子进程都继续参与下一次循环，那么最终进程总数是2^n。因为每次fork让当前进程数翻倍。比如n=3，总数 8；n=5，总数 32。如果题目要求“创建 3 个子进程”，那应该只让父进程继续循环，子进程立即退出，总数是n+1，即 4 个。

还有一种变体：循环n次，但每次fork后子进程立即退出，父进程继续。这种总进程数是1 + n。如果子进程也要创建子进程，比如每个子进程再fork一次，那就要画树。画树时从根父进程开始，每次分叉都标出当前 pid 和返回值，最后数叶子节点。这个方法虽然笨，但最不容易错。你可以在纸上画，也可以用ps --forest验证。

另外，fork返回值在父进程和子进程中不同，所以判断条件会影响进程数量。常见错误是写if (pid = fork())，把赋值当判断。父进程得到非零 pid 为真，子进程得到 0 为假，看起来能跑，但编译器会警告，而且一旦fork失败返回 -1，父进程仍然进入父分支，错误被忽略。正确写法是明确比较pid < 0、pid == 0、pid > 0。

5.2 fork炸弹为什么危险

fork炸弹就是无限创建进程的代码，比如：

while (1) { fork(); }

这段代码会指数级耗尽系统进程资源，导致机器卡死。课堂练习绝对不要运行，头歌环境也可能有进程数限制，一旦触发，你的会话可能被终止，甚至影响其他同学。我在本地测试类似逻辑时，会设置ulimit -u 50限制当前 shell 的最大进程数，或者用timeout 2 ./a.out限时运行。更安全的做法是写一个计数器，只允许创建固定数量。

ulimit -u查看或设置用户最大进程数。比如ulimit -u 100表示最多 100 个进程。如果你不小心跑了 fork 炸弹，终端可能失去响应，这时可以尝试killall a.out或重启终端。在头歌环境里，不要做这种危险实验，评测器不会容忍，你的账号也可能被限制。理解 fork 炸弹的原理就够了，没必要亲自引爆。

5.3 输出顺序不确定与评测匹配

父子进程的输出顺序由调度器决定，可能父先、子先、交替。评测器一般不会要求严格顺序，除非题目明确用wait控制。你如果遇到输出顺序不匹配，先看题面示例。示例如果父进程输出在前，不代表运行时父进程一定先执行。很多头歌题目会用“忽略顺序”的匹配方式，或者只匹配关键字段。如果评测严格按行匹配，你可以用wait让父进程等待子进程，或者让子进程sleep一小会儿，但这不是长久之计。

更稳的做法是：把所有需要顺序的输出放在同一个进程里，其他进程只负责执行任务。比如父进程收集子进程结果后再统一打印。但课堂练习可能不允许这样改，所以还是以题面为准。如果实在顺序不对，可以加fflush(stdout)和waitpid，尽量让输出可预测。实测中，setbuf(stdout, NULL)加wait能解决大部分顺序问题。

5.4 资源限制与错误处理

fork不是永远成功。进程数达到上限、内存不足、用户权限受限时，fork会返回 -1，并设置errno为EAGAIN或ENOMEM。你必须处理这个错误，否则程序可能继续执行，产生奇怪结果。标准写法是：

pid_t pid = fork(); if (pid < 0) { perror("fork"); return 1; }

在头歌环境里，进程数限制可能比较紧。如果你创建太多子进程，后面的fork会失败。这时你应该检查是否有多余进程没有回收，或者是否循环次数写错。perror会打印Resource temporarily unavailable，这就是典型的进程数限制。减少子进程数量、及时wait、避免 fork 炸弹，基本能解决。

另外，文件描述符也是资源。fork后子进程继承父进程打开的文件，如果父进程打开了大量文件，子进程也会继承引用，可能导致文件描述符耗尽。课堂练习一般涉及不到，但做管道实验时要注意关闭不需要的端口。好的习惯是：谁打开谁关闭，子进程不需要的描述符尽早close。

6. 常见问题与排查速查

6.1 编译期问题

编译报错最常见的是头文件缺失。fork需要<unistd.h>和<sys/types.h>，wait需要<sys/wait.h>，exit需要<stdlib.h>，printf需要<stdio.h>。如果你用了pid_t却没包含<sys/types.h>，可能报未知类型。C 语言标准不同也会影响声明，最好用gcc -Wall -std=gnu11编译，兼容性较好。

另一个常见问题是execlp参数列表忘了NULL。编译器不会报错，因为变参函数无法检查参数类型，但运行时可能崩溃。还有printf格式串和参数不匹配，比如%d对应pid_t，在大多数平台pid_t是int，但严格来说应该用%d并强制转换(int)getpid()。如果编译器警告format '%d' expects argument of type 'int', but argument has type 'pid_t'，加上强制转换即可。

6.2 运行期问题

运行期最烦的是输出重复、输出缺失、进程不退出。输出重复通常是缓冲区问题，用fflush或_exit解决。输出缺失可能是子进程还没执行完父进程就退出了，加wait解决。进程不退出可能是子进程调用了exec失败后没有退出，继续执行了父进程的wait逻辑，形成死等。检查exec后面是否加了perror和_exit(1)。

还有可能是wait等待了一个不存在的子进程。比如父进程只创建了一个子进程，却循环wait三次，后两次会返回 -1 并设置ECHILD。虽然不致命，但可能让程序行为混乱。正确做法是记录创建了多少子进程，就回收多少次。或者用while ((pid = wait(NULL)) > 0)循环回收，直到没有子进程。

6.3 头歌评测不通过时怎么查

头歌评测不通过时，不要盲目改代码。先做三件事：第一，把题面要求逐字读一遍，确认输出格式、数量、顺序、是否允许额外输出。第二，在本地运行，把输出保存到文件，和示例对比。第三，在代码里加临时调试信息，但提交前删除。头歌的报错有时很模糊，只说“输出不匹配”，你需要自己构造测试用例。

如果题目要求“创建 3 个子进程”，你可以在代码里打印每个子进程的 pid，然后在本地用ps确认数量。如果数量不对，检查循环里子进程有没有退出。如果题目要求“父进程等待所有子进程”，检查是否每个子进程都被wait到。如果题目要求执行外部命令，检查命令路径和参数。把大问题拆成小问题，逐个验证，比反复提交有效得多。

6.4 代码审查清单

提交前，我会按下面清单过一遍：

这张表基本覆盖了课堂练习 3.2 的绝大部分坑。你每次提交前花两分钟对照，能省下大量调试时间。尤其是“子进程退出”和“父进程回收”这两项，错一个就可能导致评测失败。

7. 经验扩展：从进程创建到线程与容器

7.1 写时复制的实际影响

fork之后，父子进程的地址空间是独立的，但内核用写时复制延迟物理内存复制。子进程一开始和父进程共享代码段、数据段、堆、栈的物理页，页表项标记为只读。任何一方写入时触发缺页异常，内核才复制该页。这个机制让fork很快，但如果你在子进程里立刻修改大量变量，复制开销会分摊到写操作上。

你可以用time命令观察一个创建大量进程的程序。如果子进程只读父进程数据，fork很快；如果子进程写大量全局数组，耗时增加。这个实验能帮你理解为什么fork后通常紧接着exec：exec会直接替换整个地址空间，避免后续写时复制开销。课堂练习里不要求测量，但知道这个背景，你写实验报告时能多一层分析。

7.2 clone、vfork与posix_spawn

除了fork，Linux 还提供vfork和clone。vfork创建子进程后，父进程会阻塞，子进程共享父进程地址空间，直到子进程调用exec或_exit。vfork的设计初衷是避免地址空间复制，但现在fork的写时复制已经很高效，vfork用得少了，而且容易出错。clone更底层，可以控制共享哪些资源，线程实现就是基于clone的。

posix_spawn是一个更高层的接口，结合了fork和exec的功能，适合在库函数里创建子进程。它比手动fork+exec更容易处理文件描述符和信号。如果你以后写需要启动外部命令的程序，可以优先考虑posix_spawn。课堂练习 3.2 重点在fork，但知道这些替代方案，能让你在面试时多答几句。

7.3 进程创建在工程中的位置

进程创建不是孤立的知识点。服务器守护进程通常要fork后让父进程退出，子进程调用setsid成为会话首进程；shell 管道要用pipe加fork加exec把多个命令串起来；并发服务器可能先fork再让子进程处理连接；容器技术则用命名空间和控制组隔离进程，但底层仍然有类似clone的创建过程。你如果在 3.2 把父子进程、文件描述符继承、回收机制搞清楚，后面学这些会顺很多。

我个人的体会是，进程创建最值得反复练的不是代码本身，而是“进程树思维”。看到一个程序，先问：谁是父，谁是子，子进程会继承什么，父进程会不会等，子进程会不会变成孤儿或僵尸。把这些问题养成习惯，你看任何多进程代码都能快速拆解。头歌课堂练习 3.2 只是一个起点，真正有价值的，是这套分析问题的方法。

最后再分享一个小技巧：如果你在头歌上做进程创建题总是差一点，可以把代码复制到本地，用strace -f -e trace=clone,fork,execve,wait4 ./a.out跑一遍，看看系统调用顺序。strace会清楚告诉你每个fork、execve、wait4发生在哪个 pid 上，比盯着printf猜顺序高效得多。这个工具在排查进程、文件、网络问题时都很好用，早一点熟悉，后面做操作系统实验会轻松很多。