父进程无需等待子进程终止的实现及子进程1秒超时终止问题解决

问题分析 #

你当前的代码逻辑存在明显缺陷：首次调用waitpid(pid, &ret, WNOHANG)时，子进程几乎还处于运行状态（fork后子进程刚启动，还没来得及退出），所以必然返回0，直接触发sleep(1)。这就导致无论子进程实际执行时间多短，父进程都会强制等待1秒，完全不符合你"超时才终止，否则正常执行完毕"的需求。

替代方案 #

不需要替换waitpid()，只需调整逻辑实现精确的超时等待。以下两种方案可以解决问题：

方案一：用信号+闹钟实现异步超时控制 #

通过alarm()设置1秒超时闹钟，结合SIGCHLD信号监听子进程结束事件，实现无冗余等待的超时控制。

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

pid_t child_pid;

// 超时触发：杀死子进程
void sigalrm_handler(int sig) {
    kill(child_pid, SIGKILL);
}

// 子进程结束：取消未触发的闹钟
void sigchld_handler(int sig) {
    alarm(0);
}

int main(int argc, char *argv[]) {
    int ret;
    child_pid = fork();

    if (child_pid == 0) {
        // 子进程执行目标命令
        execvp(argv[1], &argv[1]);
        exit(1); // exec失败则退出，返回状态1
    } else if (child_pid > 0) {
        // 注册信号处理函数
        signal(SIGALRM, sigalrm_handler);
        signal(SIGCHLD, sigchld_handler);

        // 设置1秒超时闹钟
        alarm(1);

        // 阻塞等待子进程结束（信号会处理超时/提前结束的情况）
        waitpid(child_pid, &ret, 0);

        // 处理执行结果
        if (WIFEXITED(ret)) {
            if (WEXITSTATUS(ret) == 1) {
                printf("*** Command not found: %s\n", argv[1]);
            } else {
                printf("子进程正常退出，状态码：%d\n", WEXITSTATUS(ret));
            }
        } else if (WIFSIGNALED(ret)) {
            printf("子进程被信号终止，信号编号：%d\n", WTERMSIG(ret));
        }
    } else {
        perror("fork失败");
        exit(1);
    }

    return 0;
}

方案二：用select轮询实现超时等待 #

通过select()实现分段等待（比如每次等待100ms），期间定期检查子进程状态，总等待时长不超过1秒。这种方式无需处理信号，逻辑更直观。

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

int main(int argc, char *argv[]) {
    int ret;
    pid_t child_pid = fork();

    if (child_pid == 0) {
        execvp(argv[1], &argv[1]);
        exit(1); // exec失败返回状态1
    } else if (child_pid > 0) {
        const int total_timeout_ms = 1000;
        const int interval_ms = 100;
        int waited_ms = 0;
        int child_exited = 0;

        // 分段等待并检查子进程状态
        while (waited_ms < total_timeout_ms) {
            struct timeval tv = {0, interval_ms * 1000};
            select(0, NULL, NULL, NULL, &tv);

            // 非阻塞检查子进程是否结束
            if (waitpid(child_pid, &ret, WNOHANG) == child_pid) {
                child_exited = 1;
                break;
            }
            waited_ms += interval_ms;
        }

        // 超时未结束则杀死子进程
        if (!child_exited) {
            kill(child_pid, SIGKILL);
            waitpid(child_pid, &ret, 0); // 等待子进程彻底终止
        }

        // 处理结果
        if (WIFEXITED(ret) && WEXITSTATUS(ret) == 1) {
            printf("*** Command not found: %s\n", argv[1]);
        } else if (WIFEXITED(ret)) {
            printf("子进程正常退出，状态码：%d\n", WEXITSTATUS(ret));
        } else {
            printf("子进程被信号终止，信号编号：%d\n", WTERMSIG(ret));
        }
    } else {
        perror("fork失败");
        exit(1);
    }

    return 0;
}

方案对比 #

• 信号方案：无需轮询，资源占用低，适合大多数场景；但需要处理信号上下文，注意全局变量的异步安全问题。
• 轮询方案：逻辑简单直观，无需处理信号；但存在微小的等待误差（取决于分段间隔），资源占用略高。

内容的提问来源于stack exchange，提问作者JaytheInj