fork子进程执行过快，父进程无法读取/proc/[pid]/stat，求解决方案

首先你的代码存在两个关键问题：

• wait(&ids[i]) 的用法错误：wait 的返回值才是子进程的PID，传入的参数是用来存储子进程退出状态的，不是PID。你把退出状态当成PID去拼接路径，这肯定读不到正确的文件。
• 子进程退出后，/proc 下对应的PID目录会被内核快速回收，等 wait 返回后再去读取，大概率文件已经不存在了。

针对这个问题，有几种可行的解决思路：

1. 修正PID获取，并重试读取/proc文件 #

先纠正PID的获取方式，然后在 wait 之后循环尝试打开 /proc/{pid}/stats，直到成功或者确定文件确实不存在（避免无限循环）。示例代码：

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

int main(int argc, char *argv[]) {
    int nprocesses = 3; // 示例进程数
    pid_t child_pids[nprocesses];

    // 先fork所有子进程，保存PID
    for (int i = 0; i < nprocesses; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            // 子进程逻辑，比如快速执行任务
            sleep(1); // 模拟子进程工作
            exit(0);
        } else {
            child_pids[i] = pid;
        }
    }

    // 逐个等待子进程，尝试读取stats
    for (int i = 0; i < nprocesses; i++) {
        int status;
        pid_t pid = wait(&status); // 正确获取退出的子进程PID
        char path[100];
        snprintf(path, sizeof(path), "/proc/%d/stats", pid); // 用snprintf安全拼接路径（避免缓冲区溢出）

        FILE *fd = NULL;
        int retry = 5; // 最多重试5次
        while (retry-- > 0 && fd == NULL) {
            fd = fopen(path, "r");
            if (fd == NULL) {
                usleep(100000); // 每次重试间隔100ms
            }
        }

        if (fd != NULL) {
            char buf2[BUFSIZ];
            while (fgets(buf2, BUFSIZ, fd) != NULL) {
                printf("PID %d stats: %s", pid, buf2);
            }
            fclose(fd);
        } else {
            printf("Failed to open /proc/%d/stats after retries\n", pid);
        }
    }
    return 0;
}

注意：用 snprintf 代替 strcat 拼接路径，避免缓冲区溢出的风险；同时增加重试机制，给内核一点时间保留/proc文件。

2. 子进程主动传递stats数据 #

最可靠的方式是让子进程自己读取 /proc/self/stats，然后通过管道把数据传给父进程，完全不需要依赖子进程退出后/proc文件的存在。示例代码：

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

int main(int argc, char *argv[]) {
    int nprocesses = 3;
    int pipes[nprocesses][2]; // 每个子进程对应一个管道

    for (int i = 0; i < nprocesses; i++) {
        pipe(pipes[i]); // 创建管道
        pid_t pid = fork();
        if (pid == 0) {
            close(pipes[i][0]); // 子进程关闭读端
            // 子进程读取自己的stats
            FILE *fd = fopen("/proc/self/stats", "r");
            if (fd != NULL) {
                char buf[BUFSIZ];
                while (fgets(buf, BUFSIZ, fd) != NULL) {
                    write(pipes[i][1], buf, strlen(buf)); // 写入管道
                }
                fclose(fd);
            }
            close(pipes[i][1]); // 关闭写端
            exit(0);
        } else {
            close(pipes[i][1]); // 父进程关闭写端
        }
    }

    // 父进程读取每个管道的数据
    for (int i = 0; i < nprocesses; i++) {
        char buf[BUFSIZ];
        ssize_t bytes_read;
        printf("Child %d stats:\n", i+1);
        while ((bytes_read = read(pipes[i][0], buf, BUFSIZ-1)) > 0) {
            buf[bytes_read] = '\0';
            printf("%s", buf);
        }
        close(pipes[i][0]);
        wait(NULL); // 等待子进程退出
    }
    return 0;
}

这种方法完全避免了依赖/proc文件的生命周期，是最稳定的方案。

3. 同步子进程退出时机 #

让子进程在完成任务后，等待父进程的信号再退出，这样父进程有足够时间读取/proc文件。比如用信号机制：

• 父进程fork子进程后，保存PID，子进程在退出前调用 pause() 等待信号。
• 父进程先读取 /proc/{pid}/stats，然后给子进程发送 SIGTERM 信号让其退出，最后调用 wait 回收。

这种方法也能保证父进程读取时文件存在，但需要额外的同步逻辑。

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