Linux C 管道文件操作

在 Linux 中，管道文件（Pipe File）是一种特殊的文件类型，用于在进程之间进行通信。它允许一个进程的输出直接作为另一个进程的输入，从而实现进程间的协作和数据交换。管道文件可以分为匿名管道和命名管道两种类型。

简介

用途

• 进程间通信：管道文件是实现进程间通信（IPC）的一种简单而高效的方式。它允许进程之间传递数据，而无需复杂的网络编程。

• 命令行组合 ：在 Shell 中，管道符号（|）可以将多个命令组合起来，实现复杂的操作。例如：

ls -l | grep "txt" | sort

这里，ls -l 的输出被传递给 grep，grep 的输出再被传递给 sort。

优势

• 简单易用 ：管道文件的使用方式简单，通过标准的文件操作接口（如 open()、read()、write()）即可实现进程间通信。

• 高效：数据在管道中（内存）直接传递，无需经过磁盘，减少了 I/O 开销。

• 灵活性：命名管道可以用于不相关的进程之间的通信，提供了更大的灵活性。

限制

• 数据大小限制 ：管道的容量有限（通常是 64KB 左右），如果写入的数据超过管道容量，写入进程可能会阻塞，直到数据被读取。

• 单向通信 ：匿名管道是单向的，需要双向通信时需要创建两个管道。

• 阻塞问题：如果读端没有进程读取数据，写端可能会阻塞；反之亦然。

有名管道（named pipe）

（有名）管道文件是一种特殊类型的文件，它是进程间通信机制在文件系统当中的映射。管道采用半双工的通信方式，它在ls -l命令中类型显示为p。管道文件不同于普通的磁盘文件，它只能暂存数据，而不能持久存储数据。

逻辑上管道文件存储在磁盘上，但在实际的进程通信过程中，它的数据并不是存储在磁盘上，而是存储在内存中。它本身并不存储数据。只是一个引用，用于标识一个内存中的数据缓冲区。

当进程打开这个管道文件进行读写操作时，数据实际上是在内存中进行缓冲和传输的。具体来说：

• 写入进程将数据写入管道时，数据被存储在内核分配的内存缓冲区中。
• 读取进程从管道中读取数据时，数据从内存缓冲区中读取出来。

|------|---------------------------------|
| 传输方式 | 含义 |
| 全双工 | 双方可以同时向另一方发送数据 |
| 半双工 | 某个时刻只能有一方向另一方发送数据，其他时刻的传输方向可以相反 |
| 单工 | 永远只能由一方向另一方发送数据 |

创建一个有名管道
$ mkfifo [管道名字]
使用cat打开管道可以打开管道的读端
$ cat [管道名字]
打开另一个终端，向管道当中输入内容可以实现写入内容
$ echo "string" > [管道名字]
此时读端也会显示内容

• 创建方式 ：命名管道通过 mkfifo() 系统调用或 mkfifo 命令在文件系统中创建。它具有一个文件名，并且可以被不相关的进程访问。

• 工作原理：命名管道在文件系统中创建一个特殊类型的文件（FIFO 文件）。进程可以通过文件名打开这个管道文件进行读写操作。数据写入管道后，其他进程可以通过文件名访问并读取数据。

• 特点：

  • 命名管道可以用于不相关的进程之间的通信。

  • 它是双向的，可以通过两个管道实现双向通信。

  • 命名管道在文件系统中存在，即使创建它的进程退出，管道文件仍然存在，直到被删除。

当然也可自己写编程程序来分别实现读端和写端。

• open 可以用来打开管道的一端，O_RDONLY表示打开读端，O_WRONLY表示打开写端；
• 写端打开读端未打开时，或者是读端打开写端未打开时，进程会陷入阻塞状态；
• 当读写都打开之后，可以使用 read/write 进行读写操作；
• write 暂时是不会触发阻塞的；
• 而 read 管道非常类似于 read 设备文件，如果管道当中没有数据，进程就会陷入阻塞。

示例：

读端：
int main(int argc, char const *argv[])
{
    ARGS_CHECK(argc, 2);
    int fdr = open(argv[1], O_RDONLY);
    ERROR_CHECK(fdr, -1, "open pipe read error");
    printf(" fdr is %d\n", fdr);
    char buf[256];
    ssize_t ret = read(fdr, buf, sizeof(buf));
    printf("%s\n", buf);
    return 0;
}
写端：

int main(int argc, char const *argv[])
{
    ARGS_CHECK(argc, 2);
    int fdw = open(argv[1], O_RDWR);
    ERROR_CHECK(fdw, -1, "open pipe write error");
    printf(" fdw is %d\n", fdw);
    char buf[256];
    scanf("%s",buf);
    sleep(3);
    ssize_t ret = write(fdw, buf, strlen(buf));
    
    return 0;
}

在管道的两端打开以后，任意一个进程都可以关闭管道，其表现如下：

• 若管道的写端先关闭，则之后管道的读端执行 read 操作时会立刻返回，且返回值为0；
• 若管道的读端先关闭，则之后管道的写端执行 write 操作时会触发SIGPIPE信号，导致进程异常终止。

实战：使用两个管道进行全双工通信实现简单的聊天室：

先读的一方：
int main(int argc, char const *argv[])
{
    ARGS_CHECK(argc, 3);
    //注意如果 A 首先打开一条管道的读端，那么 B 一定要首先打开这条管道的写端
    //如果 B 首先打开了另一条管道的读端会导致死锁
    int fdw = open(argv[1], O_RDWR);
    ERROR_CHECK(fdw, -1, "open pipe write error");
    int fdr = open(argv[2], O_RDONLY);
    ERROR_CHECK(fdr, -1, "open pipe read error");
    printf(" fdr is %d\n", fdr);
    printf(" fdw is %d\n", fdr);
    printf("connected\n");
    char buf[256];

    while(1){
        memset(buf, 0, sizeof(buf));
        read(STDIN_FILENO, buf, sizeof(buf));
        write(fdw, buf, strlen(buf));
        memset(buf, 0, sizeof(buf));
        ssize_t ret = read(fdr, buf, sizeof(buf));
        if(ret == 0){
            printf("A is disconnected\n");
            break;
        }
        printf("A: %s\n", buf);
       
    }
    return 0;
}
后读的一方：
int main(int argc, char const *argv[])
{
    ARGS_CHECK(argc, 3);
    int fdw = open(argv[1], O_RDWR);
    ERROR_CHECK(fdw, -1, "open pipe write error");
    int fdr = open(argv[2], O_RDONLY);
    ERROR_CHECK(fdr, -1, "open pipe read error");
    printf(" fdr is %d\n", fdr);
    printf(" fdw is %d\n", fdr);
    printf("connected\n");
    char buf[256];

    while(1){
        memset(buf, 0, sizeof(buf));
        read(STDIN_FILENO, buf, sizeof(buf));
        write(fdw, buf, strlen(buf));
        memset(buf, 0, sizeof(buf));
        ssize_t ret = read(fdr, buf, sizeof(buf));
        if(ret == 0){
            printf("A is disconnected\n");
            break;
        }
        printf("A: %s\n", buf);
       
    }
    return 0;
}

输出结果：

先读的一端：
ubuntu@ubuntu:~/MyProject/Linux/pipe$ ./piper 1.pipe 2.pipe
 fdr is 3
 fdw is 3
connected
B: hello

what are you doing?
B: emmm....
后读的一端：
ubuntu@ubuntu:~/MyProject/Linux/pipe$ ./pipew 1.pipe 2.pipe
 fdr is 4
 fdw is 4
connected
hello
A: what are you doing?

emmm....

匿名管道（Anonymous Pipe）

• 创建方式 ：匿名管道通常通过系统调用（如 pipe()）在程序中创建。它只能用于具有亲缘关系的进程（如父子进程）之间的通信。

• 工作原理：匿名管道在内存中创建一对文件描述符（file descriptors），一个用于读操作，一个用于写操作。数据从写端写入后，可以直接从读端读取。

• 特点：

  • 匿名管道是单向的，即数据只能从写端流向读端。

  • 它是临时的，当创建管道的进程及其子进程都退出后，管道会被自动销毁。

  • 由于它常常只能用于父子进程之间的通信，因此使用范围有限。

• 函数原型

#include <unistd.h>

int pipe(int pipefd[2]);

• pipefd：一个整型数组，用于存储管道的两个文件描述符。pipefd[0] 是管道的读端，pipefd[1] 是管道的写端。

• 成功时返回 0。

• 失败时返回 -1，并设置 errno 以指示错误原因。

• 调用 pipe() 时，内核会创建一对文件描述符（pipefd[0] 和 pipefd[1]）。

  • pipefd[0] 用于读操作，只能从这个描述符读取数据。

  • pipefd[1] 用于写操作，只能向这个描述符写入数据。

• 数据从写端（pipefd[1]）写入后，可以直接从读端（pipefd[0]）读取。

• 匿名管道是单向的，数据只能从写端流向读端。

int main() {
    int pipefds[2];
    int ret = pipe(pipefds);
    ERROR_CHECK(ret, -1, ,"pipe error");

    if (fork() == 0) {
        // 子进程读取管道
        close(pipefds[1]); // 关闭写端
        char buffer[80];
        read(pipefds[0], buffer, sizeof(buffer));
        printf("Child process received: %s\n", buffer);
        close(pipefds[0]);
    } else {
        // 父进程写入管道
        close(pipefds[0]); // 关闭读端
        const char* message = "Hello from parent";
        write(pipefds[1], message, strlen(message));
        close(pipefds[1]);
        wait(NULL); // 等待子进程完成
    }
    return 0;
}

匿名管道与有名管道之间的区别

• 匿名管道：

  • 只能用于具有亲缘关系的进程（如父子进程）之间的通信。不能用于不相关的进程之间的通信。

  • 使用 pipe() 创建。

  • 没有文件名，不能通过文件系统访问。

  • 生命周期与创建它的进程及其子进程相关。当所有相关进程都关闭管道的文件描述符时，管道会被自动销毁。

• 命名管道：

  • 可用于不相关进程之间。任何能够访问该文件的进程都可以打开管道进行读写操作。

  • 使用 mkfifo() 或 mkfifo 命令创建。

  • 有文件名，可以通过文件系统访问。虽然管道文件在文件系统中有一个文件名，但数据本身并不存储在磁盘上。

  • 生命周期独立于创建它的进程。

  • 即使创建它的进程退出，管道文件仍然存在于文件系统中，直到被删除。