Linux 进程等待与程序替换详解：僵尸进程防治及 exec 函数应用

• 返回值：
  • 正常回收：返回被回收子进程的 PID；
  • 非阻塞等待时无可用子进程：返回 0；
  • 失败：返回 -1；
• 核心参数解析：

✅️ 图示理解：

图中所用到的示例为什么 status 是 256 怎么把他变成预期的 11：

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

int main() {
    printf("我是父进程：pid: %d, ppid: %d\n", getpid(), getppid());
    pid_t id = fork();
    if (id < 0) {
        perror("fork");
        exit(1);
    }
    if (id == 0) {
        // 子进程
        int cnt = 5;
        while (cnt) {
            printf("我是子进程：pid: %d, ppid: %d, cnt: %d\n", getpid(), getppid(), cnt);
            sleep(1);
            cnt--;
        }
        printf("子进程退出!\n");
        exit(11);
    }
    // 父进程
    // pid_t rid = wait(NULL);
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if (rid > 0) {
        printf("等待子进程成功..., status: %d, exit code: %d\n", status, (status >> 8) & 0xFF);
    }
    return 0;
}

补充：

输出结果：

我是父进程：pid: 1234, ppid: 5678 
我是子进程：pid: 1235, ppid: 1234, cnt: 5 
我是子进程：pid: 1235, ppid: 1234, cnt: 4 
我是子进程：pid: 1235, ppid: 1234, cnt: 3 
我是子进程：pid: 1235, ppid: 1234, cnt: 2 
我是子进程：pid: 1235, ppid: 1234, cnt: 1 
子进程退出!
等待子进程成功..., status: 2816, exit code: 11

注意：这里的原理我们接着往下看就行了

1.3 解析子进程退出状态（status 参数）

status 并非普通整数，而是一个 16 位的位图，核心有效位为低 16 位，解析规则如下：

• 低 7 位：存储子进程的终止信号（若为非 0，说明子进程异常终止）；
• 高 8 位：存储子进程的退出码（仅当低 7 位为 0 时有效，即正常终止）；

（1）核心宏函数解析（推荐使用，无需手动位运算）

• WIFEXITED(status)：判断子进程是否正常终止（返回非 0 为正常）；
• **WEXITSTATUS(status)**：提取子进程的退出码（仅 WIFEXITED 为真时有效）；
• WIFSIGNALED(status)：判断子进程是否被信号终止（返回非 0 为信号终止）；
• **WTERMSIG(status)**：提取终止子进程的信号编号（仅 WIFSIGNALED 为真时有效）。

（2）代码示例：解析退出状态

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

int main() {
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子进程
        sleep(5);
        exit(10); // 正常退出，退出码 10
        // kill(getpid(), 9); // 模拟被信号终止
    } else {
        // 父进程等待
        int status;
        pid_t ret = waitpid(pid, &status, 0); // 阻塞等待
        if (ret > 0) {
            if (WIFEXITED(status)) {
                printf("子进程正常退出，退出码：%d\n", WEXITSTATUS(status));
            } else if (WIFSIGNALED(status)) {
                printf("子进程被信号终止，信号编号：%d\n", WTERMSIG(status));
            }
        }
    }
    return 0;
}

• 输出结果（正常退出）：子进程正常退出，退出码：10
• 输出结果（信号终止）：子进程被信号终止，信号编号：9

1.4 阻塞等待 vs 非阻塞等待

（1）阻塞等待（options=0）

• 父进程暂停执行，直到有子进程退出，适合不需要并发处理其他任务的场景；
• 代码简单，无需循环检测。

（2）非阻塞等待（options=WNOHANG）

• 父进程发起等待后立即返回，若无子进程退出则返回 0，不会阻塞；
• 适合父进程需要并发处理其他任务的场景（如服务器同时处理多个客户端请求）；
• 需通过循环持续检测，直到回收子进程。

（3）非阻塞等待代码示例

示例一：简单演示

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

int main() {
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子进程
        sleep(5);
        exit(1);
    } else {
        // 父进程非阻塞等待
        int status;
        pid_t ret;
        do {
            ret = waitpid(pid, &status, WNOHANG); // 非阻塞
            if (ret == 0) {
                printf("子进程仍在运行，父进程可处理其他任务...\n");
                sleep(1); // 模拟父进程其他工作
            }
        } while (ret == 0); // 直到回收成功或失败
        if (WIFEXITED(status)) {
            printf("子进程退出，退出码：%d\n", WEXITSTATUS(status));
        }
    }
    return 0;
}

示例 2：模拟工作

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

void PrintLog() {
    printf("我要打印日志\n");
}

void SyncMySQL() {
    printf("我要访问数据库!\n");
}

void Download() {
    printf("我要下载核心数据\n");
}

typedef void (*task_t)();
task_t tasks[3] = {PrintLog, SyncMySQL, Download};

int main() {
    printf("我是父进程，pid: %d, ppid: %d", getpid(), getppid());
    pid_t id = fork();
    if (id == 0) {
        // child
        int cnt = 5;
        while (cnt) {
            printf("我是子进程，pid: %d, ppid: %d, cnt: %d\n", getpid(), getppid(), cnt);
            sleep(1);
            cnt--;
        }
        exit(13);
    }
    while (1) {
        int status = 0;
        pid_t rid = waitpid(id, &status, WNOHANG);
        if (rid > 0) {
            if (WIFEXITED(status)) {
                printf("子进程正常退出，退出码：%d\n", WEXITSTATUS(status));
            } else {
                printf("进程异常退出，请注意!\n");
            }
            break;
        } else if (rid == 0) {
            sleep(1);
            printf("子进程还没有退出，父进程轮询!\n");
            for (int i = 0; i < 3; i++) {
                tasks[i]();
            }
        } else {
            printf("wait failed, who: %d, status: %d\n", rid, status);
            break;
        }
    }
    return 0;
}

（4）多进程模拟 (C/C++ 混编，利用 vector 来管理)

• 目前的最佳实践还是阻塞等待方式，我们这里再来看一个模拟的例子

#include <iostream> // 替代 stdio.h
#include <cstdlib> // 替代 stdlib.h
// unistd.h 在 C++ 中通常保留（但更推荐使用 C++ 标准库）
#include <unistd.h> // Unix 系统调用，C++ 中没有直接替代
// sys/types.h 在 C++ 中通常保留
#include <sys/types.h> // 系统类型定义
#include <sys/wait.h> // 进程等待函数
#include <vector>

const int gnum = 5;

void Work() {
    int cnt = 5;
    while (cnt) {
        printf("%d work..., cnt: %d\n", getpid(), cnt--);
        sleep(1);
    }
}

int main() {
    std::vector<pid_t> subs;
    for (int idx = 0; idx < gnum; idx++) {
        pid_t id = fork();
        if (id < 0) exit(1);
        else if (id == 0) {
            // child
            Work();
            exit(0);
        } else {
            subs.push_back(id);
        }
    }
    for (auto& sub : subs) {
        int status = 0;
        pid_t rid = waitpid(sub, &status, 0);
        if (rid > 0) {
            if (WIFEXITED(status)) {
                printf("child quit normal, exit code: %d\n", WEXITSTATUS(status));
            } else {
                printf("%d child quit error!\n", sub);
            }
        }
    }
    return 0;
}

二。进程程序替换：让子进程执行全新程序

进程程序替换是通过 exec 函数簇，将磁盘上的全新程序（代码 + 数据）加载到当前进程的地址空间，覆盖原有代码和数据，从新程序的入口开始执行。

2.1 程序替换的核心原理

• 不创建新进程：替换后进程的 PID 不变，仅用户空间的代码和数据被替换；
• 替换成功不返回：若 exec 函数调用成功，新程序会立即执行，不会回到原进程的代码；
• 替换失败返回 -1：只有当程序路径错误、权限不足等情况时才会返回错误。

通过图示加深理解：

fork() 之后，父子进程各自执行父进程代码的一部分，如果子进程想要执行一个全新的程序我们就可以使用程序替换来实现。

代码示例：

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

int main() {
    printf("我是父进程：pid: %d, ppid: %d\n", getpid(), getppid());
    pid_t id = fork();
    if (id == 0) {
        printf("我是子进程，pid: %d, ppid: %d\n", getpid(), getppid());
        sleep(1);
        execl("usr/bin/ls", "ls", "-a", "-l", NULL);
        exit(1);
    }
    // father
    pid_t rid = waitpid(id, NULL, 0);
    if (rid > 0) {
        printf("wait child process success\n");
    }
    return 0;
}

2.2 exec 函数簇（6 个核心函数，含实战示例）

exec 函数簇的核心差异在于参数传递方式、是否自动搜索 PATH、是否自定义环境变量，掌握命名规律即可快速区分：

• l（list）：参数以列表形式传递，末尾必须以 NULL 结尾；
• v（vector）：参数以字符串数组形式传递，数组末尾必须以 NULL 结尾；
• p（path）：自动搜索环境变量 PATH，无需写程序全路径；
• e（env）：自定义环境变量，需传递环境变量数组。

📝 函数原型与对比：

综合示例 (每个函数大家都可以单独去试试，myexe.c + myproc.cc)：

• myexe.c

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

int main() {
    printf("我是父进程：pid: %d, ppid: %d\n", getpid(), getppid());
    pid_t id = fork();
    if (id == 0) {
        printf("我是子进程，pid: %d, ppid: %d\n", getpid(), getppid());
        sleep(1);
        char* const argv[] = {(char*)"top", (char*)"-d", (char*)"1", (char*)"-n", (char*)"3", NULL};
        char* const env[] = {(char*)"haha = HAHA", (char*)"PATHd = xxx", (char*)"kid = miney ", (char*)"moveud = normal", (char*)"most = object"};
        // execvp(argv[0],argv);
        // execlp("ls", "ls", "-a", "-l",NULL);
        // execv("usr/bin/top", argv);
        // execl("usr/bin/ls", "ls", "-a", "-l",NULL);
        // execl("usr/bin/top", "top", "-d", "1", "-n", "3",NULL);
        // execl("./myproc", "myproc", "-a", "-b", "-c", NULL);
        // execle("./myproc", "myproc", "-a", "-b", "-c", NULL, env);
        extern char** environ;
        putenv((char*)"haha=hehe");
        putenv((char*)"class=118");
        execle("./myproc", "myproc", "-a", "-b", "-c", NULL, environ);
        //我们没有传递环境变量！
        //execl("/usr/bin/bash", "bash", "shell.sh", NULL); //?????
        //execl("/usr/bin/python3", "python3", "test.py", NULL); //?????
        exit(1);
    }
    // father
    pid_t rid = waitpid(id, NULL, 0);
    if (rid > 0) {
        printf("wait child process success\n");
    }
    return 0;
}

• myproc.cc

#include <iostream>
#include <stdio.h>
#include <unistd.h>

int main(int argc, char* argv[], char* env[]) {
    printf("===========================================\n");
    std::cout << "我是一个 C++ 程序，我变成了一个进程：" << getpid() << std::endl;
    for (int i = 0; i < argc; i++) {
        printf("argv[%d]: %s\n", i, argv[i]);
    }
    printf("===========================================\n");
    for (int i = 0; env[i]; i++) {
        printf("env[%d] : %s\n", i, env[i]);
    }
    printf("===========================================\n");
    return 0;
}

常用函数实战示例 (单独拿出来几个再看看，剩下的大家自己举一反三即可)：

• 示例 1：execlp 执行系统命令（自动搜 PATH）

#include <unistd.h>
#include <stdio.h>

int main() {
    // 执行 ls -l 命令，execlp 自动从 PATH 中查找 ls 程序
    execlp("ls", "ls", "-l", NULL);
    // 末尾必须传 NULL
    // 若替换成功，以下代码不会执行
    perror("execlp failed");
    return 1;
}

• 示例 2：execvp 执行自定义程序（数组传参）

#include <unistd.h>
#include <stdio.h>

int main() {
    char* const argv[] = {"ls", "-a", "-l", NULL};
    // 数组末尾必须为 NULL
    execvp("ls", argv);
    // 自动搜 PATH
    perror("execvp failed");
    return 1;
}

• 示例 3：execve 自定义环境变量

#include <unistd.h>
#include <stdio.h>

int main() {
    char* const argv[] = {"echo", "PATH", NULL};
    char* const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
    // 自定义环境变量
    execve("/bin/echo", argv, envp);
    // 需全路径
    perror("execve failed");
    return 1;
}

2.3 程序替换的关键注意事项

• 参数末尾必须加 NULL：exec 函数通过 NULL 判断参数结束，否则会导致参数解析错误；
• 权限检查：执行的程序必须有可执行权限（chmod +x 程序名）；
• 环境变量传递：不带 e 的 exec 函数使用当前进程的环境变量，带 e 的需手动传递环境变量数组；
• 替换后原代码失效：exec 成功后，当前进程的原有代码和数据被覆盖，后续代码不会执行（除错误处理）。

常见误区澄清：

• 程序替换会创建新进程：错误！替换后 PID 不变，仅用户空间代码和数据被覆盖；
• waitpid 只能等待指定 PID 的子进程：错误！pid=-1 时可等待任意子进程，功能同 wait；
• exec 函数可以返回成功：错误！替换成功后不会返回，只有失败时返回 -1；
• 非阻塞等待不需要循环：错误！需通过循环持续检测，直到回收子进程或失败；
• 僵尸进程可以通过 kill 删除：错误！僵尸进程已退出，只能通过父进程等待或父进程退出回收。