四十七、进程间通信——管道的协同进程和读写特性

47.1 协同进程

47.1.1 介绍

　　两个进程通过两个管道进行双向通信称为协同进程。

47.1.2 例子

　　

　　co_process.c

#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.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");
    }
    else if(pid == 0){
        /** 子进程负责从管道 a 中读取父进程写入的累加参数 x 和 y
         *  通过 exec 函数去调用 bin/add 程序进行累加
         *  将累加结果写入管道 b */
        close(fda[1]);
        close(fdb[0]);

        /** 将标准输入重定向到管道 a 的读端 */
        /** add 将从管道 a 中读取累加参数 x 和 y */
        if(dup2(fda[0], STDIN_FILENO) != STDIN_FILENO){
            perror("dup2 error");
        }
        if(dup2(fdb[1], STDOUT_FILENO) != STDOUT_FILENO){
            perror("dup2 error");
        }

        if(execlp("bin/add", "bin/add", NULL) < 0){
            perror("execlp error");
            exit(1);
        }

        close(fda[0]);
        close(fdb[1]);
    }
    else {
        /** 从标准输入上读取累加参数 x 和 y
         *  将 x 和 y 写入管道 a
         *  从管道 b 中读取累加的结果并输出 */
        close(fda[0]);
        close(fdb[1]);
        int x,y;
        printf("Please input x and y:");
        scanf("%d %d", &x, &y);

        if(write(fda[1], &x, sizeof(int)) != sizeof(int)) {
            perror("write error");
        }
        if(write(fda[1], &y, sizeof(int)) != sizeof(int)) {
            perror("write error");
        }

        int result = 0;
        if(read(fdb[0], &result, sizeof(int)) != sizeof(int)){
            perror("read error");
        }
        else {
            printf("add result is %d
", result);
        }

        close(fda[1]);
        close(fdb[0]);
        wait(0);
    }

    return 0;
}

　　add.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.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");
    }

    exit(0);
}

　　先编译 add.c ，再编译 co_process.c，运行结果如下：

　　

47.2 读写特性

47.2.1 介绍

• 通过打开两个管道来创建一个双向管道
• 管道是阻塞性的，当进程从管道中读取数据，若没有数据，进程会阻塞
• 当一个进程往管道中不断地写入数据，但是没有进程去读取数据，此时只要管道是没有满是可以的，但若管道放满数据的，则会报错
• 不完整管道：
  • 当读一个写端已经被关闭的管道时，在所有数据被读取后，read 返回 0，以表示到达了文件尾部。
  • 如果写一个读端已被关闭的管道，则产生信号 SIGPIPE，如果忽略该信号或捕捉该信号并从处理程序返回，则 write 返回 -1，同时 errno 设置为 EPIPE

47.2.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){
        /** 父进程从不完整管道（写端关闭）中读取数据 */
        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);
            }
        }

        close(fd[0]);
        wait(0);
    }
    else {
        /** 子进程负责将数据写入管道 */
        close(fd[0]);
        char *s = "1234";
        write(fd[1], s, sizeof(s));
        /** 写入数据后关闭管道的写端 */
        close(fd[1]);
    }

    return 0;
}

　　编译运行结果如下：

　　

例子2，写一个写端被关闭的不完整管道

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.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(1);
    }

    pid_t pid;
    if((pid = fork()) < 0){
        perror("fork error");
        exit(1);
    }
    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" : ", unknown");

        }
        close(fd[1]);
        wait(0);
    }
    else {
        /** 子进程关闭管道的读端 */
        close(fd[0]);
        close(fd[1]);
    }

    return 0;
}

　　编译运行：