Linux 进程等待机制：wait 与 waitpid 详解及僵尸进程治理

用 fork 创建子进程很简单，但子进程退出后若不管不顾，'僵尸进程' 就会找上门：占 PID、耗资源，甚至让系统无法新建进程。而进程等待，正是解决这一问题的核心机制 —— 它不仅能回收子进程资源，还能获取子进程的退出状态（正常结束？被信号终止？）。从 wait 的基础阻塞等待，到 waitpid 的精细化控制（指定子进程、非阻塞监听），再到解析 status 参数的退出信息，这些都是写出健壮 Linux 程序的必备技能。

一、进程等待是什么？

进程等待，是通过 wait/waitpid 这两个系统调用，实现对子进程进行状态检测与资源回收的功能。

它的核心作用有两点：

回收资源：避免子进程退出后成为'僵尸进程'，占用 PID 等系统资源；
状态检测：获取子进程的退出状态（如正常结束、被信号终止等）。

二、为什么需要进程等待？

进程等待的必要性可以分为'必须解决'和'可选关注'两类场景：

1. 必须解决：清理僵尸进程，避免资源泄漏

僵尸进程的状态为 Z—— 它的数据、代码会被内核自动清理，但 PCB（进程控制块）会残留 PID、退出状态、调度信息等属性，持续占用系统资源，且无法通过 kill -9 直接杀死。

只有父进程通过进程等待（当然，如果父进程退出，子进程会成为孤儿进程被系统进程回收），才能彻底回收 PCB 资源，否则僵尸进程会长期占用 PID、内存，最终导致系统无法创建新进程。

2. 可选关注：获取子进程的退出状态

通过进程等待，父进程可以拿到子进程的退出信息（比如是正常完成任务，还是被信号中断），以此判断子进程的任务执行结果。这一步可根据业务需求选择是否关注，但对需要确保任务可靠性的场景（如后台服务）至关重要。

三、wait 函数详解

wait 函数是 Linux 系统中一类进程控制函数，其作用是让父进程以阻塞方式等待任意一个子进程终止（不支持指定等待子进程），同时完成该子进程的资源回收与退出状态获取。

#include <sys/types.h>
#include <sys/wait.h>

pid_t wait(int *status);

返回值：成功返回被等待进程 pid，失败返回 -1。
参数：输出型参数，获取子进程退出状态，不关心则可以设置为 NULL。

场景 1：wait 等待单个子进程（仅回收资源）

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <sys/types.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(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 等待多个子进程（仅回收资源）

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <sys/types.h>

#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() {
    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);
    }
    sleep(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'依次标识所有僵尸进程被成功清理，无资源残留。

小 tip：若子进程处于运行状态、未主动退出，父进程调用 wait 时会进入阻塞状态—— 暂停自身代码执行，持续等待子进程结束；直到有子进程退出，wait 才会完成该子进程的资源回收并返回结果，父进程随之恢复执行。

由于 waitpid 的功能比 wait 更丰富，且完全涵盖了 wait 的所有能力，因此获取退出状态的测试我就不用 wait 来演示了。学会通过 waitpid 获取退出状态后，对应的 wait 用法也就自然掌握了。

四、waitpid 函数详解

waitpid 函数是 Linux 系统中让父进程灵活等待指定子进程终止，可控制阻塞/非阻塞模式、回收资源并获取退出状态的进程控制函数。

#include <sys/types.h>
#include <sys/wait.h>

pid_t waitpid(pid_t pid, int *status, int options);

返回值：
- 正常返回：收集到的子进程的进程 ID；
- 若设置 WNOHANG 且无已退出子进程可收集：返回 0；
- 调用出错：返回 -1，同时 errno 会被设置以指示错误原因。
参数：
- pid：
  - -1：等待任意一个子进程，与 wait 等效；
  - >0：等待进程 ID 与 pid 相等的子进程。
- status：输出型参数，操作系统会自动往里面填子进程的退出信息。
- options：
  - WNOHANG：非阻塞模式，若 pid 指定的子进程未结束，函数直接返回 0；
  - 0：阻塞模式，调用 waitpid 后父进程会暂停执行，直到指定的子进程状态改变（退出/被信号终止），再返回子进程 ID。

场景 1：waitpid 等待单个子进程（仅资源回收）

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <sys/types.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(11);
    }
    else {
        int cnt = 5;
        while (cnt) {
            printf("I am father, pid:%d, ppid:%d, cnt: %d\n", getpid(), getppid(), cnt);
            cnt--;
            sleep(1);
        }
        pid_t ret = waitpid(-1, NULL, 0);
        if (ret == id) {
            printf("wait success, ret: %d\n", ret);
        }
        sleep(5);
    }
    return 0;
}

waitpid 等待单个子进程

这段代码中，父进程创建子进程后，父子进程会并发执行各自的 5 次循环任务；子进程完成循环后退出并短暂进入僵尸状态，父进程完成自身任务后，调用 waitpid(-1, NULL, 0) 阻塞回收该僵尸子进程，最终'wait success'标识子进程资源被成功清理，无残留。

场景 2：waitpid 等待单个子进程（获取退出状态）

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <sys/types.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);
    }
    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;
        pid_t ret = waitpid(id, &status, 0);
        if (ret == id) {
            printf("wait success, ret: %d, status: %d\n", ret, status);
        }
        sleep(5);
    }
    return 0;
}

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 位的值）。

status 位图解析

core dump 标志是 status 位图中标识子进程终止时是否产生核心转储文件的标记位，用于调试进程崩溃原因；我们先不关注这个标志位，只需聚焦'退出码'和'终止信号'这两个核心信息即可。

手动解析 status

通过手动位运算解析 waitpid 获取的 status 值，执行结果显示 exit sig: 0、exit code: 1，完全符合预期：低 7 位（status&0x7F）为 0，说明子进程未被信号终止、属于正常退出；将 status 右移 8 位后取低 8 位（(status>>8)&0xFF）得到 1，与子进程 exit(1) 设置的退出码一致，验证了手动解析 status 位图的逻辑是正确的。

手动解析 status

手动解析结果

用宏解析 status

实际开发中我们是用宏获取退出码和终止信号的。

宏解析示例

宏解析结果

宏解析完整

通过 waitpid 获取子进程退出状态 status，再用宏解析其退出信息：先通过 WIFEXITED(status) 判断子进程是否正常退出，若是则用 WEXITSTATUS(status) 提取退出码；若不是则通过 WIFSIGNALED(status) 判断是否被信号终止，并用 WTERMSIG(status) 提取信号编号。

从运行结果看，子进程执行后'正常退出，退出码：1'，说明代码中宏的逻辑生效——子进程是正常结束的，且退出码为 1，和代码的预期解析逻辑完全一致。

常见问题：为何必须用 wait 获取子进程状态？不能用全局变量吗？

因为进程具有独立性，父子进程地址空间独立，全局变量是各自副本，子进程修改后父进程拿不到。

而且父进程不能直接访问子进程的内核数据（操作系统不允许直接碰内核数据），wait 是操作系统提供的'合法接口'——帮父进程从内核里取子进程状态，这是唯一可靠的方式。

特殊场景：父进程等待非目标子进程导致 waitpid 失败

#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);
    }
    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;
        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;
}

waitpid 失败示例

父进程创建子进程后，故意传入错误的子进程 PID 调用 waitpid，因实际退出的子进程 PID 与目标 PID 不符，导致等待失败，触发'该子进程不是我要等待的进程，wait fail'提示，证明 waitpid 仅能正确获取指定 PID 子进程的状态。

五、waitpid 非阻塞轮询

阻塞与非阻塞等待的故事

你是父进程，小张是子进程，你们要合作完成一项任务——你负责统筹，小张负责执行具体工作，而'打电话沟通'就是你们的协作方式（对应操作系统的进程通信）。

场景 1：阻塞等待

你给小张打了个电话，问她'任务做完没？'。电话拨通后，你啥也不干，就举着听筒等她回复——哪怕手头还有其他报告要写，也全放着不管。直到小张说'ok，任务做完了'，你才挂掉电话，继续处理后续的收尾工作。这就是阻塞等待：父进程调用 wait/waitpid 后，暂停自己的所有工作，直到子进程退出才恢复执行。

场景 2：非阻塞轮询

你给小张打了个电话，问她'任务做完没？'。小张说'还在弄，等等哈'，你没挂着电话干等，而是先挂掉，转身去写自己的报告。过了 10 分钟，你忙完报告里的一段内容，又给小张打了个电话问进度；她没完成，你再挂掉去处理别的事…… 循环这个'打电话→挂掉干自己事→再打电话'的过程，直到小张回复'ok'。这就是非阻塞轮询：父进程调用 waitpid(..., WNOHANG) 后，不会暂停工作，而是'问一句就走'，一边轮询子进程状态，一边处理自己的任务。

非阻塞轮询等待演示

#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");
        return 1;
    }
    else if (id == 0) {
        int cnt = 5;
        while (cnt) {
            printf("子进程 (PID：%d) 正在执行，剩余%d秒...\n", getpid(), cnt);
            cnt--;
            sleep(1);
        }
        exit(10);
    }
    else {
        int status = 0;
        while (1) {
            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 {
                printf("子进程尚未退出，父进程执行其他任务...\n");
                sleep(1);
            }
        }
    }
    return 0;
}

非阻塞轮询演示

父进程 fork 出子进程（子进程睡眠 5 秒后退出），父进程用 waitpid+WNOHANG 开启非阻塞模式，轮询子进程状态——子进程未退出时父进程可执行自身任务，退出后用 WIFEXITED 解析退出码；WNOHANG 是实现'边轮询边工作'的核心。

复杂场景下的非阻塞应用

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <time.h>

#define TASK_NUM 10

typedef void (*task_t)();
task_t tasks[TASK_NUM];

void task1() { printf("这是一个执行打印日志的任务，pid：%d\n", getpid()); }
void task2() { printf("这是一个执行检测网络健康状态的一个任务，pid：%d\n", getpid()); }
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 {
                ExecuteTask();
                usleep(500000);
            }
        }
    }
    return 12;
}

复杂场景非阻塞

这段代码构建了'任务模块 + 进程管理'的完整逻辑：先通过函数指针类型 task_t 定义任务数组，借助 InitTask 初始化、AddTask 添加 task1/task2/task3 三类任务，再通过 ExecuteTask 遍历执行数组内所有非空任务；进程层面，父进程通过 fork 创建子进程执行 5 秒倒计时任务，同时以 waitpid(..., WNOHANG) 实现非阻塞等待——子进程运行期间，父进程反复调用 ExecuteTask 执行自身任务（打印日志、检测网络、绘制界面），子进程退出后父进程解析其退出码并终止，最终实现'父进程边非阻塞等待子进程、边并行执行自有任务'的核心效果。

非阻塞轮询回收子进程的核心定位

非阻塞等待的核心目的是'回收子进程（避免僵尸进程）'，父进程同时执行的任务只是'附带轻量级工作'——这类任务需是耗时短、资源占用少的操作（比如打印日志、检测状态）；若在轮询中执行'拷贝 100G 数据'这类重任务，会大幅延迟子进程的回收时机，甚至导致僵尸进程长期占用资源，违背了非阻塞等待'及时回收'的设计初衷。

非阻塞轮询 GIF