前言
用fork创建子进程很简单，但子进程退出后若不管不顾，"僵尸进程" 就会找上门：占 PID、耗资源，甚至让系统无法新建进程。
而进程等待，正是解决这一问题的核心机制 ------ 它不仅能回收子进程资源，还能获取子进程的退出状态（正常结束？被信号终止？）。从wait的基础阻塞等待，到waitpid的精细化控制（指定子进程、非阻塞监听），再到解析status参数的退出信息，这些都是写出健壮 Linux 程序的必备技能。
本文就从僵尸进程的危害讲起，拆解进程等待的原理与系统调用细节，帮你彻底搞定进程的 "优雅收尾"。
⚙️ Linux 进程概念篇
【......】
☃ Linux 进程控制篇
目录
[℡. wait函数介绍](#℡. wait函数介绍)
场景1：wait等待单个子进程（仅回收资源，不关心退出状态）
场景2：wait等待多个子进程（仅回收资源，不关心退出状态）
[小 tip：wait 系统调用的阻塞等待特性](#小 tip：wait 系统调用的阻塞等待特性)
[℡. waitpid函数介绍](#℡. waitpid函数介绍)
[℡. status参数解析](#℡. status参数解析)
[问题：父进程为何必须用 wait 获取子进程状态？不能用全局变量吗？](#问题：父进程为何必须用 wait 获取子进程状态？不能用全局变量吗？)
[小 tip：wait/waitpid的核心作用](#小 tip：wait/waitpid的核心作用)
[特殊场景：父进程等待非目标子进程导致 waitpid 失败](#特殊场景：父进程等待非目标子进程导致 waitpid 失败)
一、进程等待是什么？
进程等待，是通过 wait/waitpid 这两个系统调用，实现对子进程进行状态检测与资源回收的功能。
它的核心作用有两点：
1、回收资源：避免子进程退出后成为 "僵尸进程"，占用 PID 等系统资源；
2、状态检测：获取子进程的退出状态（如正常结束、被信号终止等）
二、为什么需要进程等待？
进程等待的必要性可以分为 "必须解决" 和 "可选关注" 两类场景：
1、必须解决：清理僵尸进程，避免资源泄漏
僵尸进程的状态为Z------ 它的数据、代码会被内核自动清理，但 PCB（进程控制块）会残留 PID、退出状态、调度信息等属性，持续占用系统资源，且无法通过kill -9直接杀死。
只有父进程通过进程等待（++当然，如果父进程退出，子进程会成为孤儿进程被系统进程回收++），才能彻底回收 PCB 资源，否则僵尸进程会长期占用 PID、内存，最终导致系统无法创建新进程。
2、可选关注：获取子进程的退出状态
通过进程等待，父进程可以拿到子进程的退出信息（比如是正常完成任务，还是被信号中断），以此判断子进程的任务执行结果 ------ 这一步可根据业务需求选择是否关注，但对需要确保任务可靠性的场景（如后台服务）至关重要。
三、wait
℡. wait函数介绍
wait 函数是 Linux 系统中一类进程控制函数，其作用是让父进程以阻塞方式等待任意一个子进程终止（++不支持指定等待子进程++），同时完成该子进程的资源回收与退出状态获取
cpp
#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);**返回值：**成功返回被等待进程 pid，失败返回 - 1。
**参数：**输出型参数，获取子进程退出状态，不关心则可以设置成为 NULL
场景1：wait等待单个子进程（仅回收资源，不关心退出状态）
cpp
#include <stdio.h> // printf、perror 函数所需
#include <unistd.h> // fork、getpid、getppid、sleep 函数所需
#include <sys/wait.h> // wait 函数所需
#include <stdlib.h> // exit 函数所需
#include <sys/types.h> // pid_t 类型定义所需（规范写法建议显式包含）
int main()
{
pid_t id = fork();
//创建失败
if(id < 0)
{
perror("fork");
return 1;
}
//子进程
else if(id == 0)
{
int cnt = 5;
while(cnt)
{
printf("I am child, pid:%d, ppid:%d, cnt: %d\n", getpid(), getppid(), cnt);
cnt--;
sleep(1);
//*p = 100;
}
exit(2);
}
//父进程
else
{
int cnt = 10;
while(cnt)
{
printf("I am father, pid:%d, ppid:%d, cnt: %d\n", getpid(), getppid(), cnt);
cnt--;
sleep(1);
}
// 目前为止，进程等待是必须的
pid_t ret = wait(NULL);
if(ret == id)
{
printf("wait success, ret: %d\n", ret);
}
sleep(5);
}
return 0;
}
wait等待单个子进程
这段代码中，父进程创建子进程后，子进程仅循环 5 次就退出并进入僵尸状态；父进程继续执行自身 10 次循环任务，待自身任务完成后，才调用wait阻塞回收已处于僵尸状态的子进程，最终 "wait success" 标识僵尸进程被成功清理，无资源残留。
（wait参数传NULL，是因为当前场景暂不关注子进程的退出状态，仅需回收子进程资源，传NULL可忽略退出状态信息)
场景2：wait等待多个子进程（仅回收资源，不关心退出状态）
cpp
#include <stdio.h> // printf、perror 函数所需
#include <unistd.h> // fork、getpid、getppid、sleep 函数所需
#include <sys/wait.h> // wait 函数所需
#include <stdlib.h> // exit 函数所需
#include <sys/types.h> // pid_t 类型定义所需（规范写法建议显式包含）
// 定义子进程数量
#define N 5
void RunChild()
{
int cnt = 5;
while(cnt)
{
printf("I am Child Process, pid: %d, ppid:%d\n", getpid(), getppid());
sleep(1);
cnt--;
}
}
int main()
{
// 创建N个子进程
for(int i = 0; i < N; i++)
{
pid_t id = fork();
if(id == 0)
{
RunChild();
exit(0);
}
printf("create child process: %d success\n", id); // 父进程打印子进程pid
}
sleep(10); // 父进程休眠10秒（模拟自身任务）
// 等待所有子进程
for(int i = 0; i < N; i++)
{
pid_t id = wait(NULL);
if(id > 0)
{
printf("wait %d success\n", id);
}
}
sleep(5);
return 0;
}
wait等待多个子进程
这段代码中，父进程创建 5 个子进程后，每个子进程仅循环 5 次就退出并进入僵尸状态；父进程继续执行自身休眠 10 秒的任务，待自身任务完成后，才通过循环调用 wait 阻塞回收已处于僵尸状态的多个子进程，最终 "wait 进程 ID success" 依次标识所有僵尸进程被成功清理，无资源残留。
（wait 参数传 NULL，是因为当前场景暂不关注子进程的退出状态，仅需回收多个子进程的资源，传 NULL 可忽略退出状态信息）
小 tip：wait 系统调用的阻塞等待特性
若子进程处于运行状态、未主动退出，父进程调用wait时会进入阻塞状态 ------ 暂停自身代码执行，持续等待子进程结束；直到有子进程退出，wait才会完成该子进程的资源回收并返回结果，父进程随之恢复执行。
该特性确保父进程能可靠回收子进程资源，避免子进程成为僵尸进程，但也会让父进程暂时 "停滞"，适用于需要严格等待子进程完成的场景。
由于 waitpid 的功能比 wait 更丰富，且完全涵盖了 wait 的所有能力，因此获取退出状态的测试我就不用 wait 来演示了。学会通过 waitpid 获取退出状态后，对应的 wait 用法也就自然掌握了
四、waitpid
℡. waitpid函数介绍
waitpid 函数是 Linux 系统中让父进程灵活等待指定子进程终止，可控制阻塞 / 非阻塞模式、回收资源并获取退出状态的进程控制函数
cpp
#include<sys/types.h>
#include<sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);返回值：
**正常返回：**收集到的子进程的进程 ID；
**若设置
WNOHANG且无已退出子进程可收集：**返回 0；调用出错： 返回 - 1，同时
errno会被设置以指示错误原因；
参数：
pid：
**
pid=-1：**等待任意一个子进程，与wait等效；**
pid>0：**等待进程 ID 与pid相等的子进程。
status：
这是个"输出型参数"，调用wait/waitpid后，操作系统会自动往里面填子进程的退出信息，具体如何用我在后面的++status参数解析++章节进行了详解
options：
**
WNOHANG：**非阻塞模式，若pid指定的子进程未结束，函数直接返回 0；若子进程已正常结束，则返回其进程 ID（后面的++非阻塞轮询++章节会进行详解）。0：阻塞模式，调用
waitpid后父进程会暂停执行，直到指定的子进程状态改变（退出 / 被信号终止），再返回子进程 ID。
场景1：waitpid等待单个子进程（仅资源回收）
cpp
#include <stdio.h> // printf、perror 函数所需
#include <unistd.h> // fork、getpid、getppid、sleep 函数所需
#include <sys/wait.h> // wait 函数所需
#include <stdlib.h> // exit 函数所需
#include <sys/types.h> // pid_t 类型定义所需（规范写法建议显式包含）
int main()
{
// 创建单个子进程
pid_t id = fork();
if (id < 0) { // fork失败的错误处理
perror("fork");
return 1;
}
else if (id == 0) { // 子进程执行逻辑
int cnt = 5;
while (cnt)
{
// 打印子进程的PID、父进程PID、计数
printf("I am child, pid:%d, ppid:%d, cnt: %d\n", getpid(), getppid(), cnt);
cnt--;
sleep(1); // 休眠1秒，模拟子进程执行任务
}
exit(11); // 子进程退出，退出码为11
}
else { // 父进程执行逻辑
int cnt = 5;
while (cnt)
{
// 打印父进程的PID、父进程的父进程（bash）PID、计数
printf("I am father, pid:%d, ppid:%d, cnt: %d\n", getpid(), getppid(), cnt);
cnt--;
sleep(1); // 休眠1秒，模拟父进程执行任务
}
// 使用waitpid等待子进程（-1表示等待任意子进程，等价于wait；0表示阻塞等待）
pid_t ret = waitpid(-1, NULL, 0);
if (ret == id) { // 确认等待的是目标子进程
printf("wait success, ret: %d\n", ret);
}
sleep(5); // 父进程休眠5秒，观察后续状态
}
return 0;
}
waitpid等待单个子进程
这段代码中，父进程创建子进程后，父子进程会并发执行各自的 5 次循环任务；子进程完成循环后退出并短暂进入僵尸状态，父进程完成自身任务后，调用waitpid(-1, NULL, 0)阻塞回收该僵尸子进程，最终 "wait success" 标识子进程资源被成功清理，无残留。
（waitpid参数传-1表示等待任意子进程（等价于wait），传NULL是因为当前场景仅需回收资源、暂不关注子进程退出状态，传0表示阻塞等待子进程退出）
场景2：waitpid等待单个子进程（获取退出状态）
cpp
#include <stdio.h> // printf、perror 函数所需
#include <unistd.h> // fork、getpid、getppid、sleep 函数所需
#include <sys/wait.h> // wait 函数所需
#include <stdlib.h> // exit 函数所需
#include <sys/types.h> // pid_t 类型定义所需（规范写法建议显式包含）
int main()
{
pid_t id = fork(); // 创建子进程
if (id < 0) { // fork失败的错误处理
perror("fork");
return 1;
}
else if (id == 0) { // 子进程执行逻辑
int cnt = 5;
while (cnt)
{
printf("I am child, pid:%d, ppid:%d, cnt: %d\n", getpid(), getppid(), cnt);
cnt--;
sleep(1);
}
exit(1); // 子进程退出，退出码设为1
}
else { // 父进程执行逻辑
int cnt = 5;
while (cnt)
{
printf("I am father, pid:%d, ppid:%d, cnt: %d\n", getpid(), getppid(), cnt);
cnt--;
sleep(1);
}
int status; // 用于接收子进程退出状态
// 指定等待id对应的子进程，阻塞模式，并接收退出状态到status
pid_t ret = waitpid(id, &status, 0);
if (ret == id) {
// 直接打印status，观察其值（并非预期的1）
printf("wait success, ret: %d, status: %d\n", ret, status);
}
sleep(5);
}
return 0;
}
waitpid获取单个子进程退出状态
这段代码中，父进程创建子进程后，父子进程并发执行各自的 5 次循环任务；子进程完成循环后以退出码 1 终止，父进程完成自身任务后，通过waitpid阻塞等待子进程并接收其退出状态，最终打印出等待结果与状态值。
执行后可以看到，打印的status值是 256 而非预期的 1------ 这是因为waitpid接收的status并非直接存储退出码，而是一个复合格式的整数 （包含退出码、终止信号等信息），需要通过WEXITSTATUS(status)等宏才能正确解析出子进程实际的退出码。
℡. status参数解析
wait和waitpid都有一个status参数，该参数是输出型参数，由操作系统自动填充：
若传递
NULL，表示不关心子进程的退出状态信息；若传递有效的变量地址，操作系统会将子进程的退出信息（退出码、终止信号等）填充到该变量中。
但status不能简单当作整数看待，而要以 "位图" 的形式解析（通常只需关注低 16 比特位）：
低 8 比特位（0~7 位）：存储子进程的终止信号（若子进程是被信号终止的）；
高 8 比特位（8~15 位）：存储子进程的退出码（若子进程是正常退出的）。
以之前输出的status=256为例：256 对应的二进制是100000000，其高 8 比特位（第 8 位）为 1，低 8 比特位为 0------ 这意味着子进程是正常退出的，退出码为 1（对应高 8 位的值）。
core dump 标志是status位图中标识子进程终止时是否产生核心转储文件的标记位，用于调试进程崩溃原因；我们先不关注这个标志位，只需聚焦 "退出码" 和 "终止信号" 这两个核心信息即可。
手动解析status
下述演示代码我只给关键部分，只是修改了waitpid场景2的获取退出状态部分
通过++手动位运算解析waitpid获取的status值++，执行结果显示exit sig: 0、exit code: 1，完全符合预期：低 7 位（status&0x7F）为 0，说明子进程未被信号终止、属于正常退出；将status右移 8 位后取低 8 位（(status>>8)&0xFF）得到 1，与子进程exit(1)设置的退出码一致，验证了手动解析status位图的逻辑是正确的。
用宏解析status
但是实际中我们是用宏获取退出码和终止信号的
通过waitpid获取子进程退出状态status，再用宏解析其退出信息：先通过WIFEXITED(status)判断子进程是否正常退出，若是则用WEXITSTATUS(status)提取退出码；若不是则通过WIFSIGNALED(status)判断是否被信号终止，并用WTERMSIG(status)提取信号编号。
从运行结果看，子进程执行后 "正常退出，退出码：1"，说明代码中宏的逻辑生效 ------ 子进程是正常结束的，且退出码为 1，和代码的预期解析逻辑完全一致。
问题：父进程为何必须用 wait 获取子进程状态？不能用全局变量吗？
因为进程具有独立性，父子进程地址空间独立，全局变量是各自副本，子进程修改后父进程拿不到。
而且父进程不能直接访问子进程的内核数据（操作系统不允许直接碰内核数据，就像外校校长不能直接找你参赛，得经本校校长同意），wait是操作系统提供的 "合法接口"------ 帮父进程从内核里取子进程状态，这是唯一可靠的方式。
小 tip：wait/waitpid的核心作用
从内核中读取子进程的 exitcode（退出码）和 sigcode（终止信号）等退出信息；
将子进程的 "僵尸状态（Z）" 修改为 "消亡状态（X）"，释放其占用的内核资源。
特殊场景：父进程等待非目标子进程导致 waitpid 失败
cpp
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
int main()
{
// 创建子进程
pid_t id = fork();
if (id < 0)
{
perror("fork");
return 1;
}
else if (id == 0)
{
// 子进程逻辑
int cnt = 5;
while (cnt)
{
printf("I am child, pid:%d, ppid:%d, cnt: %d\n", getpid(), getppid(), cnt);
cnt--;
sleep(1);
}
exit(1); // 子进程退出，退出码1
}
else
{
// 父进程逻辑
int cnt = 5;
while (cnt)
{
printf("I am father, pid:%d, ppid:%d, cnt: %d\n", getpid(), getppid(), cnt);
cnt--;
sleep(1);
}
// 等待子进程（故意传错id+4，触发特殊场景）
int status;
pid_t ret = waitpid(id+4, &status, 0);
if (ret == id)
{
// 用宏解析退出状态
if(WIFEXITED(status))
{
printf("正常退出,退出码：%d\n",WEXITSTATUS(status));
}
else if(WIFSIGNALED(status))
{
printf("异常退出,终止信号：%d\n",WTERMSIG(status));
}
}
else
{
printf("该子进程不是我要等待的进程，wait fail\n");
}
}
sleep(5);
return 0;
}
父进程创建子进程后，故意传入错误的子进程 PID 调用waitpid，因实际退出的子进程 PID 与目标 PID 不符，导致等待失败，触发 "该子进程不是我要等待的进程，wait fail" 提示，证明waitpid仅能正确获取指定 PID 子进程的状态
五、waitpid非阻塞轮询
【阻塞/非阻塞等待小故事】
你是父进程 ，小张是子进程，你们要合作完成一项任务 ------ 你负责统筹，小张负责执行具体工作，而 "打电话沟通" 就是你们的协作方式（对应操作系统的进程通信）。
场景 1：阻塞等待
你给小张打了个电话，问她 "任务做完没？"。电话拨通后，你啥也不干，就举着听筒等她回复 ------ 哪怕手头还有其他报告要写，也全放着不管。直到小张说 "ok，任务做完了"，你才挂掉电话，继续处理后续的收尾工作。这就是阻塞等待 ：父进程调用wait/waitpid后，暂停自己的所有工作，直到子进程退出才恢复执行。
场景 2：非阻塞轮询
你给小张打了个电话，问她 "任务做完没？"。小张说 "还在弄，等等哈"，你没挂着电话干等，而是先挂掉，转身去写自己的报告。过了 10 分钟，你忙完报告里的一段内容，又给小张打了个电话问进度；她没完成，你再挂掉去处理别的事...... 循环这个 "打电话→挂掉干自己事→再打电话" 的过程，直到小张回复 "ok"。这就是非阻塞轮询 ：父进程调用waitpid(..., WNOHANG)后，不会暂停工作，而是 "问一句就走"，一边轮询子进程状态，一边处理自己的任务。
【非阻塞轮询等待演示】
cpp
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
int main()
{
// 创建子进程
pid_t id = fork();
if (id < 0)
{
perror("fork error"); // 打印fork失败信息
return 1;
}
else if (id == 0)
{
// 子进程逻辑：模拟执行任务（睡眠5秒后退出）
int cnt = 5;
while (cnt)
{
printf("子进程(PID：%d)正在执行，剩余%d秒...\n", getpid(), cnt);
cnt--;
sleep(1);
}
exit(10); // 子进程正常退出，退出码设为10
}
else
{
// 父进程：非阻塞轮询等待子进程
int status = 0;
while (1)
{
// 核心：WNOHANG开启非阻塞模式，0为阻塞模式
pid_t ret = waitpid(id, &status, WNOHANG);
if (ret > 0)
{
// 成功等待到子进程退出
printf("父进程成功等待子进程(PID：%d)\n", ret);
if (WIFEXITED(status))
{
// 子进程正常退出，解析退出码
printf("子进程正常退出，退出码：%d\n", WEXITSTATUS(status));
}
else
{
// 子进程被信号终止，解析终止信号
printf("子进程异常退出，终止信号：%d\n", WTERMSIG(status));
}
break; // 等待完成，退出轮询
}
else if (ret < 0)
{
// 等待失败（无待等待的子进程）
printf("等待子进程失败！\n");
break;
}
else // ret == 0
{
// 子进程未退出，父进程继续执行自身任务
printf("子进程尚未退出，父进程执行其他任务...\n");
sleep(1); // 模拟父进程的其他工作
}
}
}
return 0;
}
父进程fork出子进程（子进程睡眠 5 秒后退出），父进程用waitpid+WNOHANG开启非阻塞模式，轮询子进程状态 ------ 子进程未退出时父进程可执行自身任务，退出后用WIFEXITED解析退出码；WNOHANG是实现 "边轮询边工作" 的核心。
cpp
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#define TASK_NUM 10
// 重命名函数指针
typedef void(*task_t)();
// 函数指针数组
task_t tasks[TASK_NUM];
// 任务1
void task1()
{
printf("这是一个执行打印日志的任务，pid：%d\n", getpid());
}
// 任务2
void task2()
{
printf("这是一个执行检测网络健康状态的一个任务，pid：%d\n", getpid());
}
// 任务3
void task3()
{
printf("这是一个进行绘制图形界面的任务，pid：%d\n", getpid());
}
// 任务的管理代码
void InitTask()
{
for(int i = 0; i < TASK_NUM; i++) tasks[i] = NULL;
AddTask(task1);
AddTask(task2);
AddTask(task3);
}
// 添加任务
int AddTask(task_t t)
{
int pos = 0;
for(; pos < TASK_NUM; pos++)
{
//当前位置为空就跳出循环
if(!tasks[pos]) break;
}
//数组满了，添加任务失败
if(pos == TASK_NUM) return -1;
//添加任务
tasks[pos] = t;
return 0;
}
// 执行任务
void ExecuteTask()
{
for(int i = 0; i < TASK_NUM; i++)
{
//为空就跳过，遇到不为空才执行
if(!tasks[i]) continue;
tasks[i]();
}
}
int main()
{
//初始化任务数组
InitTask();
pid_t id = fork();
if(id < 0)
{
perror("fork");
return 1;
}
else if(id == 0)
{
int cnt = 5;
while(cnt)
{
printf("I am child, pid:%d, cnt: %d\n", getpid(), cnt);
cnt--;
sleep(1);
}
exit(11);
}
else
{
int status = 0;
while(1)
{
pid_t ret = waitpid(id, &status, WNOHANG);
if(ret > 0)
{
if(WIFEXITED(status))
{
printf("进程是正常完成的，退出码:%d\n", WEXITSTATUS(status));
}
else
{
printf("进程出异常了\n");
}
break;
}
else if(ret < 0)
{
printf("wait failed\n");
break;
}
else
{
//执行任务并休眠0.5秒，然后再去查看子进程是否执行结束
ExecuteTask();
usleep(500000);
}
}
}
return 12;
}
这段代码构建了 "任务模块 + 进程管理" 的完整逻辑：先通过函数指针类型task_t定义任务数组，借助InitTask初始化、AddTask添加task1/task2/task3三类任务，再通过ExecuteTask遍历执行数组内所有非空任务；进程层面，父进程通过fork创建子进程执行 5 秒倒计时任务，同时以waitpid(..., WNOHANG)实现非阻塞等待 ------ 子进程运行期间，父进程反复调用ExecuteTask执行自身任务（打印日志、检测网络、绘制界面），子进程退出后父进程解析其退出码并终止，最终实现 "父进程边非阻塞等待子进程、边并行执行自有任务" 的核心效果。
【非阻塞轮询回收子进程的核心定位】
非阻塞等待的核心目的是 "回收子进程（避免僵尸进程）"，父进程同时执行的任务只是 "附带轻量级工作"------ 这类任务需是耗时短、资源占用少的操作（比如打印日志、检测状态）；若在轮询中执行 "拷贝 100G 数据" 这类重任务，会大幅延迟子进程的回收时机，甚至导致僵尸进程长期占用资源，违背了非阻塞等待 "及时回收" 的设计初衷。
