如何用管道处理大于64KB的文件并读取至malloc分配的内存？

问题根源分析 #

你的程序在大文件下卡住，本质是管道缓冲区阻塞导致的死锁：默认管道是阻塞模式，当cat往管道写满64k缓冲区后，会阻塞等待父进程读走数据；如果父进程没有持续读取，而是等待子进程结束或只做单次读取，就会形成双方互相等待的死锁。

用O_NONBLOCK后报错，是因为cat不处理EAGAIN错误——当管道缓冲区满时，非阻塞写会直接返回错误，cat就会终止并抛出write error，导致内容没写完。

正确实现代码 #

核心逻辑是：父进程在fork后持续循环读取管道，每次读取后用realloc动态扩容缓冲区，直到read返回0（子进程关闭写端，即cat执行完成）。同时父进程必须关闭管道的写端，否则read永远不会返回0（管道写端未全部关闭）。

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

#define BUF_CHUNK 4096  // 每次读取的块大小，可调整

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <file>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        // 子进程：exec cat
        close(pipefd[0]);  // 关闭读端
        dup2(pipefd[1], STDOUT_FILENO);  // 将stdout重定向到管道写端
        close(pipefd[1]);  // 原写端不再需要

        char *const args[] = {"cat", argv[1], NULL};
        char *const envp[] = {NULL};
        execve("/bin/cat", args, envp);
        perror("execve");  // 只有execve失败才会到这里
        exit(EXIT_FAILURE);
    } else {
        // 父进程：读取管道内容
        close(pipefd[1]);  // 必须关闭写端，否则read不会返回0

        char *content = NULL;
        size_t content_size = 0;
        size_t total_read = 0;
        char buf[BUF_CHUNK];
        ssize_t bytes_read;

        while ((bytes_read = read(pipefd[0], buf, BUF_CHUNK)) > 0) {
            // 扩容缓冲区
            if (total_read + bytes_read > content_size) {
                content_size = total_read + bytes_read + BUF_CHUNK;  // 预留空间减少realloc次数
                char *tmp = realloc(content, content_size);
                if (!tmp) {
                    perror("realloc");
                    free(content);
                    close(pipefd[0]);
                    kill(pid, SIGKILL);
                    waitpid(pid, NULL, 0);
                    exit(EXIT_FAILURE);
                }
                content = tmp;
            }
            memcpy(content + total_read, buf, bytes_read);
            total_read += bytes_read;
        }

        if (bytes_read == -1) {
            perror("read");
            free(content);
            close(pipefd[0]);
            kill(pid, SIGKILL);
            waitpid(pid, NULL, 0);
            exit(EXIT_FAILURE);
        }

        // 确保内容以'\0'结尾（如果需要字符串处理）
        char *final_content = realloc(content, total_read + 1);
        if (final_content) {
            final_content[total_read] = '\0';
            content = final_content;
        }

        // 这里可以处理读取到的content，比如打印长度或内容
        printf("Read %zu bytes\n", total_read);
        // printf("Content:\n%s\n", content);

        // 清理资源
        free(content);
        close(pipefd[0]);
        waitpid(pid, NULL, 0);
        exit(EXIT_SUCCESS);
    }
}

关键注意点 #

1. 父进程必须关闭管道写端：子进程继承了管道的两端，父进程不关闭写端的话，管道的写端始终处于打开状态，read会一直等待更多数据，永远不会返回0。
2. 循环读取+动态扩容：每次读取固定块大小，用realloc逐步扩大缓冲区，避免一次性分配过大内存，同时保证不会丢失数据。
3. 错误处理：任何步骤失败时，要及时释放内存、关闭文件描述符、终止子进程，避免资源泄漏。

其他问题解答 #

• 能否中断耗时过久的管道进程？
  可以用alarm()设置超时，结合信号处理函数终止子进程。比如在父进程中设置alarm(10)（10秒超时），然后捕获SIGALRM信号，在信号处理函数中调用kill(pid, SIGKILL)终止cat进程。注意信号处理中要避免调用非异步安全函数，比如printf。

• 能否通过while循环动态调整管道大小？
  不行。管道大小只能通过fcntl(pipefd, F_SETPIPE_SZ, size)调整，且需要提前知道目标大小（或者逐步增大），但这种方式不如边读边写高效——管道的设计就是流式传输，边写边读才是正确的使用方式，调整大小属于冗余操作，没必要。

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