Linux 匿名管道通信：原理与代码实战

3.1 匿名管道的创建流程

匿名管道依靠 pipe() 系统调用创建，内核会完成三件事：

1. 开辟一段环形缓冲区（默认大小一般为 4096 字节/页，可通过 proc 文件系统调整），作为数据中转站；
2. 分配两个文件描述符：fd[0] 读端、fd[1] 写端，严格单向通信；
3. 返回文件描述符，由调用进程持有，fork() 子进程会完整继承这两个文件描述符。

关键特性：匿名管道是半双工通信，数据只能从写端流入、读端流出，不支持双向传输；且数据遵循**先进先出（FIFO）**原则，无消息边界，是字节流通信。

匿名管道的创建函数：

#include <unistd.h>
int pipe(int pipefd[2]);

函数参数

• pipefd：整型数组，是输出型参数，用于保存管道的读、写文件描述符：
  • pipefd[0]：管道的读端，仅用于读取管道中的数据；
  • pipefd[1]：管道的写端，仅用于向管道中写入数据。

返回值

• 成功：返回 0；
• 失败：返回 -1，并设置**errno**表示错误原因。

注意：调用 pipe 函数的进程会同时持有管道的读端和写端，若要实现两个进程间的单向通信，需要在进程创建后关闭各自无用的文件描述符，避免数据读写异常。

3.2 匿名管道的使用示例

下面的示例实现了一个基础的匿名管道通信：从键盘读取数据写入管道，再从管道读取数据输出到屏幕，直观展示管道的读写操作。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>

int main() {
    int fds[2];
    char buf[100];
    int len;
    
    if (pipe(fds) == -1) {
        std::perror("make pipe");
        std::exit(1);
    }
    
    while (std::fgets(buf, 100, stdin)) {
        len = std::strlen(buf);
        if (write(fds[1], buf, len) != len) {
            std::perror("write to pipe");
            break;
        }
        std::memset(buf, 0x00, sizeof(buf));
        if ((len = read(fds[0], buf, 100)) == -1) {
            std::perror("read from pipe");
            break;
        }
        if (write(1, buf, len) != len) {
            std::perror("write to stdout");
            break;
        }
    }
    return 0;
}

该示例中，进程自身同时完成管道的写和读操作，虽然未实现跨进程通信，但清晰展示了管道的基本读写流程：通过 fd[1] 写，通过 fd[0] 读，操作接口与普通文件完全一致。

四、核心深挖：匿名管道的底层原理

匿名管道本身由单个进程创建，要实现跨进程通信，需要借助**fork**函数创建子进程 —— 子进程会继承父进程的文件描述符表，从而与父进程共享同一个管道的读、写端，这是匿名管道实现亲缘进程通信的核心原理。

4.1 fork 共享管道的核心原理

**fork**函数创建的子进程会复制父进程的文件描述符表，包括父进程创建的管道读、写端文件描述符，因此父子进程会共享同一个内核管道缓冲区，实现数据互通。其核心步骤分为三步：

• 父进程创建管道：父进程调用 pipe 创建管道，持有 fd[0]（读）和 fd[1]（写）两个文件描述符；
• 父进程 fork 创建子进程：子进程继承父进程的文件描述符表，同样持有管道的 fd[0] 和 fd[1]；
• 关闭无用的文件描述符：根据通信方向，父、子进程分别关闭无用的读 / 写端，实现单向通信。

例如要实现父进程写、子进程读，则：

• 父进程关闭读端**fd[0]，仅保留写端fd[1]**；
• 子进程关闭写端**fd[1]，仅保留读端fd[0]**。

4.2 从文件描述符视角理解管道通信

从文件描述符的角度，我们可以更清晰地看到父子进程共享管道的过程，以父读子写为例：

步骤 1：父进程创建管道 父进程的文件描述符表中，0、1、2 分别为标准输入、标准输出、标准错误，pipe创建的管道分配到 3（读端 fd[0]）和 4（写端 fd[1]）。

父进程：0(tty) 1(tty) 2(tty) 3(pipe 读) 4(pipe 写)

步骤 2：父进程 fork 创建子进程 子进程复制父进程的文件描述符表，此时父子进程的文件描述符 3、4 均指向同一个内核管道缓冲区。

父进程：0(tty) 1(tty) 2(tty) 3(pipe 读) 4(pipe 写)
子进程：0(tty) 1(tty) 2(tty) 3(pipe 读) 4(pipe 写)

核心关键点：父子进程的文件描述符指向同一个内核管道缓冲区，这是进程间能通过管道通信的根本原因；关闭无用描述符则是为了保证通信的单向性，避免出现数据读写的混乱。

步骤 3：关闭无用文件描述符 父进程关闭写端 4，子进程关闭读端 3，此时管道形成单向的'子写父读'通道，数据只能从子进程写入，父进程读出。

父进程：0(tty) 1(tty) 2(tty) 3(pipe 读) -
子进程：0(tty) 1(tty) 2(tty) - 4(pipe 写)

4.3 实战示例分析四个场景案例

下面的示例实现了子进程向管道写入字符串，父进程从管道读取并打印的功能，是'子写父读'的标准实现：

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

// 子进程:w
void WriteData(int wfd) {
    int cnt = 1;
    pid_t id = getpid();
    while (true) {
        std::string message = "hello father process, ";
        message += "cnt:" + std::to_string(cnt++) + ", my pid is: " + std::to_string(id);
        write(wfd, message.c_str(), message.size());
        sleep(1);
    }
}

// 父进程:r
void ReadData(int rfd) {
    char inbuffer[1024];
    while (true) {
        ssize_t n = read(rfd, inbuffer, sizeof(inbuffer) - 1);
        if (n > 0) {
            inbuffer[n] = '\0';
            std::cout << getpid() << "# " << inbuffer << std::endl;
        }
    }
}

int main() {
    // 1. 创建管道成功
    int pipefd[2] = {0};
    int n = pipe(pipefd); // 系统调用
    (void)n;

    // 2. 创建子进程
    pid_t id = fork();
    if (id == 0) {
        // 3. 形成单向通信的信道
        // 子进程:w
        close(pipefd[0]);
        WriteData(pipefd[1]);
        close(pipefd[1]);
        exit(0);
    } else {
        // 3. 形成单向通信的信道
        // 父进程:r
        close(pipefd[1]);
        ReadData(pipefd[0]);
        close(pipefd[0]);
    }
    // 0->read fd, 1->write fd
    // 0->嘴巴->读，1->笔->写
    return 0;
}

通过对上述案例进行一定程度上的修改，主要有四种情况需要注意：

1. 父写子读：父进程关闭读端，子进程关闭写端。
2. 子写父读：子进程关闭写端，父进程关闭读端（即上述示例）。
3. 父写父读：单进程测试管道读写能力。
4. 子写子读：单进程测试管道读写能力。

关键在于确保每个进程只保留自己需要的读写端，否则会导致死锁或数据无法正确流转。

五、站在内核较低——管道的本质

从文件描述符视角，我们理解了管道的使用流程，而从内核视角，我们能看透管道的底层实现 —— 管道的本质是内核中的一块缓冲区，由两个 file 结构体指向同一个 inode，贴合 Linux'一切皆文件'的设计思想。

5.1 管道的内核数据结构

在 Linux 内核中，管道的底层实现涉及三个核心数据结构：

• file 结构体：进程的文件描述符表中的每个项都指向一个 file 结构体，记录文件的操作方式、当前偏移量等信息；
• inode 结构体：用于描述文件的物理属性，管道的 inode 中保存了管道缓冲区的地址、大小、读写位置等核心信息；
• 管道缓冲区：内核中的一块连续内存，是管道实际存储数据的地方。

对于匿名管道，父子进程的 fd[0] 和 fd[1] 会分别指向不同的 file 结构体，但这两个 file 结构体最终会指向 同一个 inode 结构体，而该 inode 指向内核中的 管道缓冲区。

5.2 管道的内核实现逻辑

当进程对管道执行 read/write 操作时，内核的处理逻辑如下：

• 写操作 write(fd[1], data, len)：内核将数据从进程地址空间复制到管道缓冲区，并更新 inode 中的写位置；
• 读操作 read(fd[0], buf, len)：内核将管道缓冲区中的数据复制到进程地址空间，并更新 inode 中的读位置；
• 缓冲区同步：内核会保证管道缓冲区的读写同步，若缓冲区为空，读操作会阻塞；若缓冲区满，写操作会阻塞。

简单来说，管道的读写操作本质是进程地址空间与内核缓冲区之间的数据拷贝，而两个进程共享同一个内核缓冲区，就实现了数据的跨进程传递。

5.3 管道特点总结

• 高效：无需用户态与内核态多次拷贝（相对于某些其他 IPC）；
• 简单：API 少，易于上手；
• 局限：仅限亲缘进程，半双工，无消息边界。

六、总结：匿名管道的适用场景

匿名管道的优势在于实现简单、效率高、内核原生支持，适合以下场景：

• Shell 命令行的管道符实现；
• 父子/兄弟进程间的简单数据流转；
• 小批量、单向的字节流传输。

如果需要双向通信、无亲缘进程通信、大数据持久化传输，就需要进阶学习命名管道、共享内存、消息队列等更强大的 IPC 机制。