IPC之管道详解

迈不过友情╰ 2022-09-25 10:14 287阅读 0赞

**基本概念：**

linux管道（也叫无名管道）由pipe函数创建，提供一个单路（单向）数据流。（**注：linux不支持全双工的管道，某些系统支持**）

PIPE(2)                                                  Linux Programmer's Manual                                                  PIPE(2)
    
    NAME
           pipe, pipe2 - create pipe
    
    SYNOPSIS
           #include <unistd.h>
    
           int pipe(int pipefd[2]);

返回：若成功则为0，若出错则为-1

该函数返回两个文件描述符：fd\[0\]和fd\[1\]。前者打开来读，后者打开来写。

**管道的典型用途**是以下述方式为两个不同进程（一个是父进程，一个是子进程）提供进程间通信的手段。首先，由一个进程（它将成为父进程）创建一个管道后调用fork派生一个自身的副本，如图4-3所示：

![20160818234006602][]

接着，父进程关闭这个管道的读出端，子进程关闭同一管道的写入端。这就在父子进程间提供了一个单向数据流，如图4-4所示：

![20160818234155197][]

我们在某个shell中输入一个像下面这样的命令时：

**who | sort | lp**

该shell将执行上述步骤创建三个进程和其间的两个管道。它还把每个管道的读出端复制到相对应进程的标准输入，把每个管道的写入端复制到相应进程的标准输出。图4-5展示了这样的管道线：

![20160818234640977][]

到此为止所示的所有管道都是半双工的即单向的，只提供一个方向的数据流。当需要一个双向数据流时，我们必须创建两个管道，每个方向一个。实际步骤如下：

（1）创建管道1（fd1\[0\]和fd1\[0\]）和管道2（fd2\[0\]和fd2\[0\]）

（2）fork

（3）父进程关闭管道1的读出端（fd1\[0\]）

（4）父进程关闭管道2的写入端（fd2\[1\]）

（5）子进程关闭管道1的写入端（fd1\[1\]）

（6）子进程关闭管道2的读出端（fd2\[0\]）

它产生如图4-6所示的管道布局  
![20160818235419393][]

**例子1，提供一个双向数据流的两个管道，这里的pipe返回的文件描述符默认是阻塞模式。**

gcc pipe.c

#include <unistd.h>
    #include <stdio.h>
    #include <errno.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <string.h>
    
    #define MAXLINE 1024
    
    void Perror(const char *s)
    {
        perror(s);
        exit(EXIT_FAILURE);
    }
    
    void client(int readfd, int writefd)
    {
        /* read msg  */
        int i = 0;
        for (i; i<3; i++) {
            char buff[MAXLINE] = {0};
            int n = read(readfd, buff, MAXLINE);
            if (n > 0) {
                printf("read from server:%s\n", buff);
            }
        }
        char *buff = "goodby server";
        write(writefd, buff, strlen(buff));
    }
    
    void server(int readfd, int writefd)
    {
        /* send msg  */
        int i = 0;
        for (i; i<3; i++) {
            char buff[MAXLINE] = {0};
            sprintf(buff, "hello world %d", i);
            int n = write(writefd, buff, strlen(buff));
            //printf("send to client:%d bytes\n", n);
            sleep(1);
        }
        char buff[MAXLINE] = {0};
        int n = read(readfd, buff, MAXLINE);
        if (n > 0) {
            printf("read from client:%s\n", buff);
        }
    }
    
    int main()
    {
        int pipe1[2], pipe2[2];
        pid_t childpid;
    
        if (pipe(pipe1) == -1) {
            Perror("create pipe1 failed");
        }
        if (pipe(pipe2) == -1) {
            Perror("create pipe2 failed");
        }
    
        childpid = fork();
        if (childpid == 0) { /* child */
            close(pipe1[1]);
            close(pipe2[0]);
    
            server(pipe1[0], pipe2[1]);
            exit(0);
        }
        close(pipe1[0]);
        close(pipe2[1]);
    
        client(pipe2[0], pipe1[1]);
    
        /* parent */
        waitpid(childpid, NULL, 0);
    
        return 0;
    }

**例子1运行结果：**

![20160818235740523][]

**关于管道的大小，可以通过ulimit -a或者ulimit -p命令查看，显示结果为512\*8=4kb，实际值并不是这个，后面通过实验证明。**

![20160819000007658][]

**例子2，管道大小的测试**

gcc pipe\_size.c

#include <unistd.h>
    #include <stdio.h>
    #include <errno.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <string.h>
    
    #define MAXLINE 1024
    
    void Perror(const char *s)
    {
        perror(s);
        exit(EXIT_FAILURE);
    }
    
    void client(int readfd, int writefd)
    {
        /* read msg  */
        int i = 0;
        while (1) {
            sleep(1);
        }
    }
    
    void server(int readfd, int writefd)
    {
        /* read msg  */
        int i = 0;
        int sum = 0;
        for (i; i<=1000000; i++) {
            char buff[MAXLINE] = "0123456789";
            int n = write(writefd, buff, strlen(buff));
            sum += n;
            printf("send to pipe:%d bytes, i:%d\n", sum, i);
        }
    }
    
    int main()
    {
        int pipe1[2], pipe2[2];
        pid_t childpid;
    
        if (pipe(pipe1) == -1) {
            Perror("create pipe1 failed");
        }
        if (pipe(pipe2) == -1) {
            Perror("create pipe2 failed");
        }
    
        childpid = fork();
        if (childpid == 0) { /* child */
            close(pipe1[1]);
            close(pipe2[0]);
    
            server(pipe1[0], pipe2[1]);
            exit(0);
        }
        close(pipe1[0]);
        close(pipe2[1]);
    
        client(pipe2[0], pipe1[1]);
    
        /* parent */
        waitpid(childpid, NULL, 0);
    
        return 0;
    }

**例子2运行结果：**

![20160819000552969][]

**分析运行结果发现，管道的size与ulimit返回的结果并不相符合。实际上管道的大小是64kb，这也与测试结果吻合。**

管道大小的分析文章，可以参考：[http://blog.csdn.net/judwenwen2009/article/details/44134415][http_blog.csdn.net_judwenwen2009_article_details_44134415]

**关于数据持久性：**当一个管道或FIFO的最后一次关闭发生时，仍在该管道或FIFO上的数据将被丢弃。

**关于更多**：[IPC之管道和FIFO的额外属性][IPC_FIFO]

参考：《unix网络编程》·卷2

End;

[20160818234006602]: /images/20220718/333b767e29114bbcb7ba14ac04d115ea.png
[20160818234155197]: /images/20220718/dac3e9e8a42c4a82bafc77bded7fd414.png
[20160818234640977]: /images/20220718/4037c94d92ef42fa9e85321e5974eb2a.png
[20160818235419393]: /images/20220718/45356056852f4a33b9b15d6b470ef2e3.png
[20160818235740523]: /images/20220718/eb722b2d7ffd427eb0d71a14e56d084c.png
[20160819000007658]: /images/20220718/d66f3b4094ac48cca4eebefe8b760983.png
[20160819000552969]: /images/20220718/214c3ee8fa424bb6af013048410390a8.png
[http_blog.csdn.net_judwenwen2009_article_details_44134415]: http://blog.csdn.net/judwenwen2009/article/details/44134415
[IPC_FIFO]: http://blog.csdn.net/daiyudong2020/article/details/52269690