C语言实现双管道执行ls | sort | grep r的代码问题求助

核心错误分析 #

1. 管道创建时机错误 #

原代码先执行fork()创建第一个子进程，再创建管道fd1和fd2。但fork()会复制父进程当前时刻的资源状态，子进程只能拿到fork()时父进程已有的文件描述符。后续父进程创建的管道，子进程完全无法访问，导致管道通信根本无法建立。

正确逻辑是：先创建所有需要的管道，再fork子进程，这样所有进程都能共享管道的文件描述符。

2. 进程分支逻辑混乱 #

• pid2仅在第一个子进程（pid1==0）中被赋值，父进程（pid1>0）和第三个进程的pid2值未定义，导致if(pid2>0)的判断完全不可靠。
• 嵌套fork的方式导致三个进程的职责划分模糊，容易出现逻辑冲突。

3. 未关闭无关管道描述符 #

部分进程未关闭不需要的管道端，会导致后续进程阻塞在read()调用上——管道的读端会一直等待写端关闭，才会判定输入结束。

4. 未处理子进程退出 #

原父进程未等待子进程执行完毕，会导致僵尸进程，且程序可能提前终止，无法输出完整结果。

修正后的代码 #

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

#define WRITE 1
#define READ 0

int main(int argc, char** argv)
{
    int fd1[2], fd2[2];
    pid_t pid_ls, pid_sort, pid_grep;

    // 1. 先创建两个管道，确保所有进程共享文件描述符
    if (pipe(fd1) == -1) {
        perror("pipe fd1 failed");
        exit(EXIT_FAILURE);
    }
    if (pipe(fd2) == -1) {
        perror("pipe fd2 failed");
        exit(EXIT_FAILURE);
    }

    // 2. 创建ls进程：输出写入fd1
    pid_ls = fork();
    if (pid_ls == -1) {
        perror("fork ls failed");
        exit(EXIT_FAILURE);
    }

    if (pid_ls == 0) {
        close(fd1[READ]);          // 关闭不需要的读端
        close(fd2[READ]);          // 完全不需要第二个管道
        close(fd2[WRITE]);

        dup2(fd1[WRITE], STDOUT_FILENO);
        close(fd1[WRITE]);         // 重定向后关闭原描述符

        execlp("ls", "ls", NULL);
        perror("execlp ls failed");
        exit(EXIT_FAILURE);
    }

    // 3. 创建sort进程：从fd1读，写入fd2
    pid_sort = fork();
    if (pid_sort == -1) {
        perror("fork sort failed");
        exit(EXIT_FAILURE);
    }

    if (pid_sort == 0) {
        close(fd1[WRITE]);         // 关闭fd1的写端
        close(fd2[READ]);          // 关闭fd2的读端

        dup2(fd1[READ], STDIN_FILENO);
        close(fd1[READ]);

        dup2(fd2[WRITE], STDOUT_FILENO);
        close(fd2[WRITE]);

        execlp("sort", "sort", NULL);
        perror("execlp sort failed");
        exit(EXIT_FAILURE);
    }

    // 4. 创建grep进程：从fd2读
    pid_grep = fork();
    if (pid_grep == -1) {
        perror("fork grep failed");
        exit(EXIT_FAILURE);
    }

    if (pid_grep == 0) {
        close(fd1[READ]);          // 完全不需要第一个管道
        close(fd1[WRITE]);
        close(fd2[WRITE]);         // 关闭fd2的写端

        dup2(fd2[READ], STDIN_FILENO);
        close(fd2[READ]);

        execlp("grep", "grep", "r", NULL);
        perror("execlp grep failed");
        exit(EXIT_FAILURE);
    }

    // 父进程：关闭所有管道描述符，等待所有子进程退出
    close(fd1[READ]);
    close(fd1[WRITE]);
    close(fd2[READ]);
    close(fd2[WRITE]);

    waitpid(pid_ls, NULL, 0);
    waitpid(pid_sort, NULL, 0);
    waitpid(pid_grep, NULL, 0);

    exit(EXIT_SUCCESS);
}

修正说明 #

1. 管道创建前置：在fork()前完成管道创建，确保所有子进程能继承到有效的管道文件描述符，这是进程间管道通信的核心前提。
2. 明确进程分工：通过三次独立fork()创建三个子进程，分别对应ls、sort、grep，父进程仅负责清理资源和等待子进程，逻辑清晰无歧义。
3. 严格关闭无关描述符：每个进程只保留自己需要的管道端，避免因管道未完全关闭导致的阻塞问题。
4. 等待子进程退出：用waitpid()确保所有子进程执行完毕，避免僵尸进程，保证程序输出完整结果。

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