Linux进程间通信-管道（pipe）

本系列文章主要是学习记录Linux下进程间通信的方式。

常用的进程间通信方式：管道、FIFO、消息队列、信号量以及共享存储。

参考文档：《UNIX环境高级编程（第三版）》

参考视频：Linux进程通信  推荐看看，老师讲得很不错

Linux核心版本：2.6.32-431.el6.x86_64

注：本文档只是简单介绍IPC，更详细的内容请查看参考文档和相应视频。

本文介绍利用管道进行进程间的通信。

1  简介

管道是最古老的一种方式，局限性：

• 半双工方式，数据只能在一个方向上流动；
• 只能在具有公共祖先的两个进程间使用。

2  函数接口

#include <unistd.h>
int pipe(int pipefd[2]);
说明：创建一个pipe
返回值：成功返回0，出错返回-1
参数[out]：fd保存返回的两个文件描述符，fd[0]为读而打开，fd[1]为写而打开。fd[1]的输出是fd[0]的输入。

3  通信模型

通信模型一：进程先调用pipe，接着调用fork，从而创建从父进程到子进程的IPC通道。

通信模型二：从父进程到子进程的通道。父进程关闭管道的读端（fd[0]），子进程关闭写端（fd[1]）。

 

当管道一端被关闭后，以下两条规则起作用：

当读（read）一个写端已被关闭的管道时，在所有数据都被读取后，read返回0，表示文件结束。

如果写（write）一个读端已被关闭的管道，则产生信号SIGPIPE。

 4  读写特性

1）可通过打开两个管道来创建一个双向的管道；

2）管道是阻塞性的，当进程从管道中读取数据，若没有数据进程会阻塞；

3）当一个进程往管道中不断的写入数据但是没有进程去读取数据，此时只要管道没有满是可以的，但若管道满的则会报错。

 5  测试代码

 （1）实例1

创建一个从父进程到子进程的管道，并且父进程通过该管道向子进程传送数据。

#include <stdio.h>
#include <unistd.h>

#define MAXLINE 512

int main(void)
{
    int n;
    int fd[2];
    pid_t pid;
    char line[MAXLINE];

    if (pipe(fd) < 0) {  //创建管道
        perror("pipe error!");
        return -1;
    }
    if ((pid = fork()) < 0) {  //创建子进程
        perror("fork error!");
        return -1;
    } else if (pid > 0) {  //父进程
        close(fd[0]);    //父进程关闭读管道
        write(fd[1], "hello world
", 12);  //父进程向管道中写入数据
        close(fd[1]);
        wait(0);  //等待子进程结束
    } else {  //子进程
        close(fd[1]);  //子进程关闭写管道
        n = read(fd[0], line, MAXLINE);  //子进程从管道中读取数据
        write(STDOUT_FILENO, line, n);   //标准输出
        close(fd[0]);
    }

    return 0;
}

（2）实例2

使用pipe实现类似于：cat /etc/passwd | grep root这个命令。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

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

int main(void)
{
    int fd[2];
    int i = 0;
    pid_t pid;

    if (pipe(fd) < 0) {
        perror("pipe error");
        exit(1);
    }

    for (i = 0; i < 2; i++) {
        pid = fork();
        if (pid < 0) {
            perror("fork error");
            exit(1);
        } else if (pid == 0) {
            if (i == 0) {  //第一个子进程
                //负责往管道写入数据
                close(fd[0]);  //关闭读端
                //cat命令执行结果是标准输出，需要将标准输出重定向到管道写端
                //下面命令执行的结果会写入到管道中，而不是输出到屏幕
                if (dup2(fd[1], STDOUT_FILENO) != STDOUT_FILENO) {
                    perror("dup2 error");
                    exit(1);
                }
                close(fd[1]);  //已经复制了一份，原来的可以关闭
                //调用exce函数执行cat命令
                if (execvp(cmd1[0], cmd1) < 0) {
                    perror("execvp error");
                    exit(1);
                }
                break;
            }
            if (i == 1) {  //第二个子进程
                //负责从管道读取数据
                close(fd[1]);  //关闭写端
                //grep命令默认读取的内容来源于标准输入
                //需要将标准输入重定向到管道的读端
                //下面命令执行时从管道的读端读取内容，而不是从标准输入读取
                if (dup2(fd[0], STDIN_FILENO) != STDIN_FILENO) {
                    perror("dup2 error");
                    exit(1);
                }
                close(fd[0]);
                //调用exce函数执行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;
}

（3）实例3

使用pipe实现一个协同进程。

 创建两个管道，父进程向管道1中写入数据，并从管道2中读取子进程计算出的结果值；

子进程从管道1中读取数据，并调用add程序进行累加，将累加的结果写入到管道2中。

add程序实现代码：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main(void)
{
    int x, y;

    if (read(STDIN_FILENO, &x, sizeof(int)) < 0) {
        perror("read error");
    }
    if (read(STDIN_FILENO, &y, sizeof(int)) < 0) {
        perror("read error");
    }

    int result = x + y;
    if (write(STDOUT_FILENO, &result, sizeof(int)) < sizeof(int)) {
        perror("write error");
    }

    return 0;
}

协同进程实现代码：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main(void)
{
    int fda[2], fdb[2];

    if ((pipe(fda) < 0) || (pipe(fdb) < 0)) {
        perror("pipe error");
        exit(1);
    }
    
    pid_t pid;
    pid = fork();
    if (pid < 0) {  //子进程
        perror("fork error");
        exit(1);
    } else if (pid == 0) {
        //1、子进程负责从管道a中读取父进程写入的累加参数x和y
        //2、通过exec函数调用/bin/add程序进行累加
        //3、将累加结果写入到管道b
        close(fda[1]);
        close(fdb[0]);
        //将标准输入重定向到管道a的读端
        //add程序中将从管道a中读取累加参数x和y
        if (dup2(fda[0], STDIN_FILENO) != STDIN_FILENO) {
            perror("dup2 error");
        }
        //将标准输出重定向到管道b的写端
        //add程序累加后的结果会写入到管道b
        if (dup2(fdb[1], STDOUT_FILENO) != STDOUT_FILENO) {
            perror("dup2 error");
        }
        close(fda[0]);
        close(fdb[1]);
        if (execlp("bin/add", "bin/add", NULL) < 0) {
            perror("execlp error");
            exit(1);
        }
    } else {  //父进程
        //1、从标准输入上读取累加参数x和y
        //2、将x和y写入管道a
        //3、从管道b中读取累加的结果并输出
        close(fda[0]);
        close(fdb[1]);
        //1
        int x, y;
        printf("please input x and y: ");
        scanf("%d %d", &x, &y);
        //2
        if (write(fda[1], &x, sizeof(int)) != sizeof(int)) {
            perror("write error");
        }
        if (write(fda[1], &y, sizeof(int)) != sizeof(int)) {
            perror("write error");
        }
        //3
        int result = 0;
        if (read(fdb[0], &result, sizeof(int)) != sizeof(int)) {  //阻塞式读写
            perror("read error");
        }
        printf("add result is %d
", result);
        close(fda[1]);
        close(fdb[0]);
        wait(0);
    }


    return 0;
}

测试结果：

[root@192 ipc]# gcc -o bin/add add.c
[root@192 ipc]# gcc -o bin/co_pro c_process.c
[root@192 ipc]# ./bin/co_pro
please input x and y: 12 23
add result is 35

（4）案例4

实现一个不完整管道：当读一个写端已被关闭的管道时，在所有数据被读取后，read返回0，以表示到达了文件尾部。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.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) {  //父进程
        //父进程从不完整管道（写端关闭）中读取数据
        sleep(5);  //等子进程将管道写端关闭
        close(fd[1]);
        while (1) {
            char c;
            if (read(fd[0], &c, 1) == 0) {
                printf("
write-end of pipe closed
");
                break;
            } else {
                printf("%c", c);
            }
        }
    } else {  //子进程
        // 子进程负责将数据写入管道
        close(fd[0]);
        char *s = "1234";
        write(fd[1], s, sizeof(s));
        close(fd[1]);
    }

    return 0;
}

（5）案例5

实现一个不完整管道：当写一个读端被关闭的信号，则产生信号SIGPIPE，如果忽略该信号或捕捉该信号并从处理程序返回，则write返回-1，同时errno设置为EPIPE。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>

/*
 * 不完整管道：写入一个读端已经被关闭的管道
*/

void sig_handler(int signo)
{
    if (signo == SIGPIPE) {
        printf("SIGPIPE occured
");
    }
}

int main(void)
{
    int fd[2];

    if (pipe(fd) < 0) {
        perror("pipe error");
        exit(0);
    }

    pid_t pid;
    if ((pid = fork()) < 0) {
        perror("fork error");
    } else if (pid > 0) {  //父进程
        //父进程负责将数据写入到不完整管道（读端关闭）中
        sleep(5);
        close(fd[0]);
        if (signal(SIGPIPE, sig_handler) == SIG_ERR) {
            perror("signal sigpipe error");
            exit(1);            
        }
        char *s = "1234";
        if (write(fd[1], s, sizeof(s)) != sizeof(s)) {
            fprintf(stderr, "%s, %s
", strerror(errno), (errno == EPIPE) ? "EPIPE" : ", unkown");            
        }
        close(fd[1]);
        wait(0);
    } else {  //子进程
        //关闭管道的读端
        close(fd[0]);
        close(fd[1]);
    }

    return 0;
}

6  标准库中的管道操作

函数实现的操作：创建一个管道，fork一个子进程，关闭未使用的管道端，执行一个shell运行命令，然后等待命令终止。

（1）函数原型

#include <stdio.h>
FILE *popen(const char *command, const char *type);
返回值：成功返回文件指针，出错返回NULL。
参数command：命令的路径。
参数type：读写特性，”r”或”w”
int pclose(FILE *stream);

函数popen先执行fork，然后调用exec执行command，并且返回一个标准I/O文件指针。

如果type是“r”，则文件指针连接到command的标准输出。

如果type是"w"，则文件指针连接到command的标准输入。

（2）popen内部原理

 （3）实例

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    FILE *fp;

    //命令执行的结果放置到fp指向的结构体缓存中
    fp = popen("cat /etc/passwd", "r");
    char buf[512] = {0};
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        printf("%s", buf);
    }
    pclose(fp);

    printf("----------------------------------
");
    //为wr命令提供统计的数据
    fp = popen("wc -l", "w");
    fprintf(fp, "1
2
3
");
    pclose(fp);

    return 0;
}