四十六、进程间通信——管道的分类与读写

46.1 管道介绍

46.1.1 管道通信

• 管道是针对于本地计算机的两个进程之间的通信而设计的通信方法，建立管道后，实际获得两个文件描述符：一个用于读取而另一个用于写入
• 最常见的 IPC 机制，通过 pipe 系统调用
• 管道是单工的，数据只能向一个方向流动，需要双向通信时，需要建立起两个管道
• 数据的读出和写入：
  • 一个进程向管道中写的内容被管道另一端的进程读出。
  • 写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据
• 管道实际上就是建立在内核区域的一块缓存

46.1.2 管道分类

• 匿名管道：
  • 在关系进程中进行（父进程和子进程、兄弟进程之间）
  • 由 pipe 系统调用，管道由父进程建立
  • 管道位于内核空间，其实是一块缓存
• 命名管道（FIFO）
  • 两个没有任何关系的进程之间通信可通过命名管道进行数据传输，本质是内核中的一块缓存，另在文件系统中以一个特殊的设备文件（管道文件）存在
  • 通过系统调用 mkfifo 创建

46.1.3 管道创建

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

• 函数参数：两个文件描述符数组
  • fd[0]：为 pipe 的读端
  • fd[1]：为 pipe 的写端
  • fd[0] 用于读取管道，fd[1] 用于写入管道
• 返回值：成功返回 0；出错返回 -1

　　

　　案例

　　

46.1.4 管道读写

• 管道主要用于不同进程间通信。实际上，通常先创建一个管道，再通过 fork 函数创建一个子进程

　　

46.2 例子

46.2.1 管道应用

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

/**
 *  父进程通过管道传输两个数据给子进程
 *  由子进程负责从管道中读取并输出
 */
int main(void)
{
    int fd[2];

    /** 创建管道 */
    if(pipe(fd) < 0){
        perror("pipe error");
        exit(1);
    }

    pid_t pid;
    if((pid = fork()) < 0){
        perror("fork error");
        exit(1);
    }
    else if(pid > 0) { ///< 父进程
        close(fd[0]);    ///< 父进程用来写入数据
        int start = 1, end = 100;
        if((write(fd[1], &start, sizeof(int))) != sizeof(int)) {
            perror("write error");
            exit(1);
        }

        if((write(fd[1], &end, sizeof(int))) != sizeof(int)) {
            perror("write error");
            exit(1);
        }

        close(fd[1]);
        wait(0);
    }
    else {  ///< 子进程
        close(fd[1]);   ///< 子进程用来读取数据
        int start, end;
        if(read(fd[0], &start, sizeof(int)) < 0){
            perror("read error");
            exit(1);
        }

        if(read(fd[0], &end, sizeof(int)) < 0){
            perror("read error");
            exit(1);
        }

        close(fd[0]);
        printf("child process read start: %d, end %d
", start, end);
    }

    return 0;
}

　　编译运行：

　　

 46.2.2 在管道系统中使用 excu 函数

　　

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

char *cmd1[3] = {"/bin/cat", "/etc/passwd", NULL};
char *cmd2[3] = {"/bin/grep", "root", NULL};

int main(void)
{
    int fd[2];
    if(pipe(fd) < 0){
        perror("pipe error");
        exit(1);
    }

    int i = 0;
    pid_t pid;
    for(; i < 2; i++){
        pid = fork();
        if(pid < 0){
            perror("fork error");
            exit(1);
        }
        else if(pid == 0){
            if(i == 0){ /** 第一个子进程负责往管道写入数据 */
                /** 关闭读端 */
                close(fd[0]);

                /** 将标准输出重定向到管道的写端
                 * 下面命令的执行的结果会写入到管道中，而不是输出到屏幕 */
                if(dup2(fd[1], STDOUT_FILENO) != STDOUT_FILENO)
                {
                    perror("dup2 error");
                }

                close(fd[1]);

                /** 调用 exec 函数执行 cat 命令 */
                if(execvp(cmd1[0], cmd1) < 0){
                    perror("execvp error");
                    exit(1);
                }
                break;
            }

            if(i == 1){/** 第二个子进程负责从管道读取数据 */
                /** 关闭写端 */
                close(fd[1]);

                /** 将标准输入重定向到管道的读端 */
                if(dup2(fd[0], STDIN_FILENO) != STDIN_FILENO){
                    perror("dup2 error");
                }

                close(fd[0]);

                /** 调用 exec 函数执行 grep 命令 */
                if(execvp(cmd2[0], cmd2) < 0){
                    perror("execvp error");
                    exit(1);
                }

                break;
            }
        }
        else {
            if(i == 1){
                /** 父进程要等到子进程全部创建完毕才去回收 */
                close(fd[0]);
                close(fd[1]);
                wait(0);
                wait(0);
            }

        }
    }
    return 0;
}

　　执行结果如下：