管道通信（上）

管道通信（上）

（一）概述

　　Linux Shell 都允许重定向，而重定向使用的就是管道。例如，ps | grep vsftpd 。管道是单向的、先进先出的、无结构的、固定大小的字节流。管道是Linux由Unix那里继承过来的进程间的通信机制，它是Unix早期的一个重要通信机制。其思想是，在内存中创建一个共享文件，从而使通信双方利用这个共享文件来传递信息。由于这种方式具有单向传递数据的特点，所以这个作为传递消息的共享文件就叫做“管道”。它把一个进程的标准输出和另一个进程的标准输入连接在一起。写进程在管道的尾端写入数据，读进程在管道的读端读出数据。数据读出之后将从管道中移走，其他读进程都不能再读到这些数据。管道提供了简单的流控制机制。进程试图读空管道时，在有数据写入管道之前，进程将一直阻塞。同样，管道已经满时，进程在试图写管道，在其他进程从管道中移走数据之前，写进程将一直阻塞。

（二）匿名管道

　　匿名管道是具有共同祖先的进程之间的一种通信方式，因此通常用于父子进程或者兄弟进程之间的通信，在由父进程创建的子进程将会赋值父进程包括文件在内的一些资源。如果父进程创建子进程之前创建了一个文件，那么这个文件的描述符就会被父进程在随后所创建的子进程所共享。也就是说，父、子进程可以通过这个文件进行通信。

 

 参数：长度为2的整型数组

返回值：成功返回0，失败返回-1，errno会被设置，可以通过perror打印错误信息。

函数使用示例：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
int main(int argc, char const *argv[])
{
    int fd_pipe[2];
    if(pipe(fd_pipe) == -1)
    {
        perror("pipe");
        exit(1);
    }
    if(write(fd_pipe[1],"hello pipe",strlen("hello pipe")) == -1)
    {
        perror("write");
        exit(1);
    }
    char buf[128] = "";
    if(read(fd_pipe[0],buf,sizeof(buf)) == -1)
    {
        perror("read");
        exit(1);
    }
    printf("%s
",buf);
    close(fd_pipe[1]);
    close(fd_pipe[0]);
    return 0;
}

运行结果：

 父子进程之间通信示例：父进程从终端读取内容，并将内容发送给子进程。

#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main(int argc, char const *argv[])
{
    int fd_pipe[2];
    pid_t pid;
    if(pipe(fd_pipe) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    if((pid = fork()) == -1)
    {
        perror("Fail to fork");
        exit(1);
    }
    else if (pid > 0)
    {
        char buf[20] = "";
        while (1)
        {
            if(read(STDIN_FILENO,buf,sizeof(buf)) == -1)
            {
                perror("Fail to read from std");
                exit(1);
            }
            buf[strlen(buf) - 1] = '';
            if(write(fd_pipe[1],buf,sizeof(buf)) == -1)
            {
                perror("Fail to write to pipe:");
                exit(1);
            }
            memset(buf,0,sizeof(buf));   
        }
    }
    else if (pid == 0)
    {
        char buf[128] = "";
        while (1)
        {
            if(read(fd_pipe[0],buf,1024) == -1)
            {
                perror("Fail to read:");
                exit(1);
            }
            printf("read from parent by pipe message is %s
",buf);
            memset(buf,0,sizeof(buf));
        }
           
    }
    return 0;
}

运行结果：

 （三）匿名管道读写规律

（1）只读不写——当管道有内容时，读取内容，无内容时会进入阻塞态，当我面修改属性为非阻塞时，程序会直接结束。

代码：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
int main(int argc, char const *argv[])
{
    int fd_pipe[2];
    if(pipe(fd_pipe) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    char buf[128] = "";
    if(write(fd_pipe[1],"hello pipe",strlen("hello pipe")) == -1)
    {
        perror("write");
        exit(1);
    }
    if(read(fd_pipe[0],buf,sizeof(buf)) == -1)
    {
        perror("fail to read");
        exit(1);
    }
    printf("%s
",buf);
    memset(buf,0,sizeof(buf));
    printf("Read again
");
    if(read(fd_pipe[0],buf,sizeof(buf)) == -1)
    {
        perror("fail to read");
        exit(1);
    }
    printf("%s
",buf);
    return 0;
}

运行结果：

 我们首先在管道内写点数据，进程可以正常的从管道中读取数据，读完之后，管道内没有数据了，此时当我们再读的时候，就会进入阻塞态，我们再试一下，用fcntl使管道为非阻塞，看看会有怎样的效果。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
int main(int argc, char const *argv[])
{
    int fd_pipe[2];
    if(pipe(fd_pipe) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    char buf[128] = "";
    fcntl(fd_pipe[0],F_SETFL,O_NONBLOCK);
    if(write(fd_pipe[1],"hello pipe",strlen("hello pipe")) == -1)
    {
        perror("write");
        exit(1);
    }
    if(read(fd_pipe[0],buf,sizeof(buf)) == -1)
    {
        perror("fail to read");
        exit(1);
    }
    printf("%s
",buf);
    memset(buf,0,sizeof(buf));
    printf("Read again
");
    if(read(fd_pipe[0],buf,sizeof(buf)) == -1)
    {
        perror("fail to read");
        exit(1);
    }
    printf("%s
",buf);
    return 0;
}

（2）只写不读——管道写满之后就会进入阻塞态

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
int main(int argc, char const *argv[])
{
    int fd_pipe[2];
    if(pipe(fd_pipe) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    if(write(fd_pipe[1],"hello pipe",strlen("hello pipe")) == -1)
    {
        perror("write");
        exit(1);
    }
    printf("write successful
");
    if(write(fd_pipe[1],"hello pipe",strlen("hello pipe")) == -1)
    {
        perror("write");
        exit(1);
    }
    printf("write successful
");
    if(write(fd_pipe[1],"hello pipe",strlen("hello pipe")) == -1)
    {
        perror("write");
        exit(1);
    }
    printf("write successful
");
    close(fd_pipe[0]);
    close(fd_pipe[1]);
    return 0;
}

我们看到，三次都写成功了，但可以一直写吗？而且管道是有大小的，我们可以写多少呢？

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
int main(int argc, char const *argv[])
{
    int fd_pipe[2];
    if(pipe(fd_pipe) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    int count = 0;
    while (1)
    {
        char buf[1024] = "";
        if(write(fd_pipe[1],buf,sizeof(buf)) == -1)
        {
            perror("write");
            exit(1);
        }
        count++;
        printf("count = %d
",count);
        sleep(1);
    }
    
    close(fd_pipe[0]);
    close(fd_pipe[1]);
    return 0;
}

 从程序中不难看出，管道是有大小的，当我们写满之后，就会进入阻塞态。

（3）只有读端——程序会直接结束

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
int main(int argc, char const *argv[])
{
    int fd_pipe[2];
    if(pipe(fd_pipe) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    close(fd_pipe[1]);
    char buf[128] = "";
    if(read(fd_pipe[0],buf,sizeof(buf)) == -1)
    {
        perror("read");
        exit(1);
    }
    printf("%s
",buf);
    close(fd_pipe[0]);
    return 0;
}

 按道理来讲，此时读管道应该进入阻塞态的，但由于我们关闭了写端，所以程序就直接结束了。

（4）只有写端——管道会破裂

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
int main(int argc, char const *argv[])
{
    int fd_pipe[2];
    if(pipe(fd_pipe) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    close(fd_pipe[0]);
    if(write(fd_pipe[1],"hello pipe",strlen("hello pipe")) == -1)
    {
        perror("write");
        exit(1);
    }
    printf("write successful
");
    close(fd_pipe[1]);
    return 0;
}

 我们运行发现程序直接结束了，其实这里大家要知道一点，就是只有写端的时候，我们写内容时是有一个SIGPIPE信号产生的，表明管道破裂了，我们可以通过一个函数——signal()来看。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
#include<signal.h>
void hander(int sig)
{
    printf("SIGPIPE occurrenced
");
    exit(1);
}
int main(int argc, char const *argv[])
{
    signal(SIGPIPE,hander);
    int fd_pipe[2];
    if(pipe(fd_pipe) == -1)
    {
        perror("fail to pipe");
        exit(1);
    }
    close(fd_pipe[0]);
    if(write(fd_pipe[1],"hello pipe",strlen("hello pipe")) == -1)
    {
        perror("write");
        exit(1);
    }
    printf("write successful
");
    close(fd_pipe[1]);
    return 0;
}