fork / exec / wait —— 进程的生与死
在终端敲 ls -l，按下回车，shell 是怎么把这个命令跑起来的？答案是 Linux 进程模型的核心三件套：fork 复制自己 → exec 替换映像 → wait 等子进程退出。这篇把这条链路上每个系统调用、每个细节讲清楚。
0. 引言：shell 怎么跑命令
整个 Linux 进程生态都是这个模式：bash、systemd、init、Docker、k8s …全部基于 fork/exec/wait。下面拆解。
1. fork —— 一变二
#include<unistd.h>pid_tfork(void);
返回值有两个（这是 fork 最魔幻的特点）：
pid_t pid = fork();if (pid < 0) { perror("fork"); exit(1);} else if (pid == 0) { /* 子进程走这里 */ printf("child: my pid is %d\n", getpid());} else { /* 父进程走这里 */ printf("parent: child pid is %d\n", pid);}
1.1 fork 之后两个进程几乎一样
子进程从 fork() 之后开始，与父进程"平行"执行。它继承父进程的：
- 文件描述符（open 的文件、socket、pipe）
- pid_t 自身的值（getpid() 返回各自的 pid）
不继承的：
1.2 Copy-On-Write（COW）
fork() 看起来像“复制整个进程”，但 Linux 不会立刻复制几 GB 内存。它真正复制的是页表视图：父子进程先指向同一批物理页，并把这些页标记成只读；只有某个进程真的写某一页时，内核才复制那一页。
| | |
|---|
| fork 刚返回 | | |
| 读共享页 | | |
| 写共享页 | | |
| 更新映射 | | |
| 子进程 exec | | 如果 fork 后马上 exec，很多页根本不会复制 |
所以 fork() 本身很快：主要成本是创建子进程、复制页表、标记 COW。真正的内存复制被延迟到“写入某个页”的那一刻。
2. exec —— 替换进程映像
fork 后子进程跟父进程一模一样，但通常我们想让它去跑另一个程序。exec 系列函数把当前进程的代码段、数据段、堆、栈全部替换成新程序，但保留 pid、父子关系、文件描述符。
2.1 exec 家族：6 个变种
#include<unistd.h>intexecl(constchar *path, constchar *arg, ..., NULL);intexeclp(constchar *file, constchar *arg, ..., NULL);intexecle(constchar *path, constchar *arg, ..., NULL, char *const envp[]);intexecv(constchar *path, char *const argv[]);intexecvp(constchar *file, char *const argv[]);intexecve(constchar *path, char *const argv[], char *const envp[]);
字母含义：
实际上只有 execve 是真正的系统调用，其他都是 libc 包装。
2.2 最常用的两个
/* 知道完整路径 */char *argv[] = {"ls", "-l", NULL};execv("/bin/ls", argv);/* 不知道路径，让 PATH 帮你找 */execvp("ls", argv);
执行成功后当前进程的代码就被替换了，从新程序的 main 开始执行。exec 之后的代码永远不会被执行到（除非 exec 失败）。
execvp("ls", argv);/* 只有 exec 失败才会到这里 */perror("execvp");exit(1);
2.3 fork + exec 的标准模式
pid_t pid = fork();if (pid == 0) { /* 子进程 */ char *argv[] = {"ls", "-l", NULL}; execvp("ls", argv); /* 走到这里说明 exec 失败 */ perror("execvp"); _exit(127);} else if (pid > 0) { /* 父进程 */ int status; waitpid(pid, &status, 0); /* ... */}
⚠️ 子进程 exec 失败时用 _exit 而不是 exit，避免触发父进程注册的 atexit handler（那些通常只该跑一次）。
3. wait —— 等子进程退出 + 回收资源
子进程退出后并不立即消失，它的退出码、CPU 时间等需要被父进程"收尸"。负责收尸的是 wait 系列。
3.1 三个函数
#include<sys/wait.h>pid_twait(int *status);pid_twaitpid(pid_t pid, int *status, int options);intwaitid(idtype_t idtype, id_t id, siginfo_t *info, int options);
最常用的 waitpid：
int status;pid_t cpid = waitpid(pid, &status, 0); /* 阻塞等到指定 pid 退出 */if (WIFEXITED(status)) { printf("normal exit, code = %d\n", WEXITSTATUS(status));} else if (WIFSIGNALED(status)) { printf("killed by signal %d\n", WTERMSIG(status));} else if (WIFSTOPPED(status)) { printf("stopped by signal %d\n", WSTOPSIG(status));}
pid 参数：
options：
0WNOHANGWUNTRACEDWCONTINUED
3.2 status 解析的 5 个宏
| |
|---|
WIFEXITED(status) | 是否正常退出（return / exit / _exit） |
WEXITSTATUS(status) | |
WIFSIGNALED(status) | |
WTERMSIG(status) | |
WCOREDUMP(status) | |
3.3 非阻塞 wait
主进程不想阻塞等子进程：
while (1) { pid_t pid = waitpid(-1, &status, WNOHANG); if (pid == 0) break; /* 没有已退出的子进程 */ if (pid < 0) { if (errno == ECHILD) break; /* 没有子进程了 */ perror("waitpid"); break; } /* 处理 pid 的退出 */}
或者用 SIGCHLD 信号处理（见后文）。
4. 僵尸进程 vs 孤儿进程
4.1 僵尸进程（Zombie）
子进程已退出但父进程还没 wait —— 进程 PCB 还在内核里挂着，状态显示 Z。
ps -ef... S PID PPID TIME CMD... Z 1234 500 0:00 [foo] <defunct> ← 僵尸
危害：占用 PID 表项，pid 用尽时新进程起不来。
修复：
- 或者忽略
SIGCHLD（signal(SIGCHLD, SIG_IGN)）—— 子进程退出时内核自动回收，不变僵尸 - 或者在
SIGCHLD handler 里循环 waitpid(-1, NULL, WNOHANG)
4.2 孤儿进程（Orphan）
父进程先退出了，子进程还活着 —— 这个子进程的 ppid 变成 1（init）或某个 subreaper。init 会自动 wait，所以孤儿不可怕。
孤儿是常态：每次 nohup 后台跑命令、daemon 化都会产生。
4.3 双 fork：daemon 化
pid_t pid1 = fork();if (pid1 > 0) exit(0); /* ① 父进程退出 *//* 子进程继续 */setsid(); /* 脱离控制终端 */pid_t pid2 = fork();if (pid2 > 0) exit(0); /* ② 子进程退出 *//* 孙进程才是真正的 daemon */chdir("/");umask(0);close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO);/* daemon 主逻辑 */
为什么要 fork 两次？
- 第一次 fork：让 shell 能立刻拿到第一个子进程的退出，shell 不阻塞
setsid- 第二次 fork：确保孙进程不再是 session leader，防止以后误打开 tty 把它当控制终端
现代系统用 systemd 管理服务，不用手写 daemon 化，但理解这个模式仍然重要。
5. 实战：写一个迷你 shell
#include<stdio.h>#include<stdlib.h>#include<string.h>#include<unistd.h>#include<sys/wait.h>intmain(void){ char line[1024]; while (printf("$ "), fflush(stdout), fgets(line, sizeof line, stdin)) { line[strcspn(line, "\n")] = 0; if (strcmp(line, "exit") == 0) break; /* 简单分词：空格分隔 */ char *argv[64] = {0}; int argc = 0; for (char *tok = strtok(line, " "); tok && argc < 63; tok = strtok(NULL, " ")) { argv[argc++] = tok; } if (argc == 0) continue; pid_t pid = fork(); if (pid == 0) { execvp(argv[0], argv); fprintf(stderr, "command not found: %s\n", argv[0]); _exit(127); } else if (pid > 0) { int status; waitpid(pid, &status, 0); if (WIFEXITED(status)) printf("[exit %d]\n", WEXITSTATUS(status)); } } return 0;}
50 行实现了一个能跑常见命令的 shell。真正的 bash 复杂在管道、重定向、job control、tab 补全、history 等，但核心机制就是 fork + exec + wait。
6. fork 的近亲：vfork、posix_spawn、clone
6.1 vfork
跟 fork 类似，但：
- 子进程必须立即
exec 或 _exit，不能动父进程内存
历史原因：早期没有 COW，fork 真的全量拷贝，开销大；vfork 用于"立即 exec"的场景省拷贝。
今天有了 COW，vfork 几乎没必要用，标准也已经标记为 obsolete。但 musl libc / Android bionic 仍保留实现，特殊场景偶尔见。
6.2 posix_spawn
intposix_spawn(pid_t *pid, constchar *path, const posix_spawn_file_actions_t *file_actions, const posix_spawnattr_t *attrp, char *const argv[], char *const envp[]);
把 fork + exec 合在一起，一次系统调用搞定。在某些场景（嵌入式、no MMU 系统）比 fork 快。
POSIX 标准但用得不多，Linux 上 fork+exec 已经够快。
6.3 clone
Linux 特有，fork 和 pthread_create 底层都靠它：
intclone(int (*fn)(void *), void *stack, int flags, void *arg, ...);
flags 决定共享什么资源：
CLONE_VMCLONE_FSCLONE_FILESCLONE_SIGHANDCLONE_THREAD
不同组合得到不同的"创建模式"：fork 是 0 共享，pthread_create 是几乎全共享，容器是部分共享 (CLONE_NEWPID 等)。
7. 几个常踩的坑
7.1 fork 后未 reset 信号处理
子进程继承父进程所有的 signal handler。如果你打算 exec 一个新程序，handler 大概率不该跟过去：
if (fork() == 0) { /* exec 之前 reset */ for (int i = 1; i < NSIG; i++) signal(i, SIG_DFL); execvp(...);}
但实际上 exec 自己会把所有非 SIG_IGN 的 handler 自动 reset 成 SIG_DFL。SIG_IGN 状态会保留。
7.2 fork 后子进程 fd 共享
父子进程的 fd 是共享的（指向同一个 file 内核对象）。子进程 read 文件，文件偏移会动，父进程下次 read 也受影响：
int fd = open("file", O_RDONLY);if (fork() == 0) { char buf[10]; read(fd, buf, 10); /* 偏移 → 10 */ _exit(0);}wait(NULL);char buf[10]; read(fd, buf, 10); /* 从偏移 10 开始读 */
7.3 fork 后 exec 之前别 malloc
子进程从 fork 出来到 exec 之间这段时间，父进程的堆状态是冻结快照。这段时间调 malloc 在多线程程序里可能死锁（mtrace 锁）。只调 async-signal-safe 函数（基本就是 syscall 包装）。
7.4 stdio 缓冲区在 fork 时被复制
printf("hello\n"); /* 进了 stdio 行缓冲 */fork();/* 父子各自 flush 一次 → "hello" 可能被打两遍 */
fork 前 fflush(stdout)，或者用 unbuffered 输出。
7.5 wait 之前主进程就退出 → 孤儿
通常没事（init 接管），但一些 daemon 框架会监听不到。如果你要追踪子进程退出，要 wait。
8. 总结表
| | |
|---|
fork | | 父返回子 pid，子返回 0；COW 优化；fd 共享 |
execve | | pid 不变，代码全换；exec 后旧代码不再执行 |
wait | | |
vfork | | |
posix_spawn | | |
clone | | |
10个月宝宝每天需要喝多少奶粉？