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

这段代码中，父进程创建子进程后，子进程仅循环 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;
}

这段代码中，父进程创建 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;
}

这段代码中，父进程创建子进程后，父子进程会并发执行各自的 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;
}

执行后可以看到，打印的 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 获取的 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 是操作系统提供的'合法接口'——帮父进程从内核里取子进程状态，这是唯一可靠的方式。

特殊场景：父进程等待非目标子进程导致 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;
}

父进程创建子进程后，故意传入错误的子进程 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 数据'这类重任务，会大幅延迟子进程的回收时机，甚至导致僵尸进程长期占用资源，违背了非阻塞等待'及时回收'的设计初衷。