一、进程通信原理

我们知道进程间相互独立，具有独立性。那么我们要实现两个进程之间的通信就需要，让这两个进程看到同一个文件。然后一个进程对文件写入，一个进程对文件内容进行读取，这就是现实了进程间的通信。

二、什么是管道

管道是进程间通信的一种方式。

进程间通信的方式：

管道：

匿名管道
命名管道

System V

System V 消息队列
System V 贡献内存
System V 信号量

POSIX IPC

消息队列
共享内存
信号量
互斥量
条件变量
读写锁

我们把一个进程连接到另外一个进程的数据流成为一个“管道”

Linux中的|就是管道。

三、创建一个匿名管道

#include<unistd.h>

int pipe(int fd[2]);
//fd:文件描述符数组
//返回值：成功返回0，失败返回错误代码。

此时就创建除了一个有读写权限的数据流。这里只有一个进程，管道还无法实现通信，下文会自习讲解。

四、fork共享管道的原理

这就是实现一个管道通信的原理：

1.父进程先通过pipe创造一个匿名管道

2.父进程再通过fork创建一个子进程，（重点：子进程继承了父进程的fd文件描述符）

3. 父进程保留读端，子进程保留写端

4.这样就实现了：子进程写入，父进程读出的进程通信。

通过文件描述符，深度理解管道：

以下是进程间通信实例：

#include<unistd.h>
#include<stdlib,h>
#include<stdio.h>
#include<errno.h>
#include<string.h>
#include<assert.h>

#define ERR_EXIT(m) do{
    perror(m);
    exit(EXIT_FAILURE);
}while(0);

int main(int argc,char *argv[])
{
    int piprfd[2];//输出型参数 ,会返回两个文件描述符
    if(pipe(pipefd)==-1)
    ERR_EXIT("pipe error");//也可以这样写：cout<<pipe(pipefd);return 1;
    pid_t pid;
    pid=fork();
    assert(pid!=-1);//意料之外用if意料之内用assert
    if(pid==0)//子进程
    {
        close(pipefd[0]);
        write(pipefd[1],"hello",5);
        close(pipefd[1]);
        exit(EXIT_SUCCESS);
    }

    close(pipefd[1]);
    char buf[10]={0};
    read(pipefd[0],buf,10);
    printf("%s",buf);
    return 0;


}

上面的pipefd数组为输出型参数，pipe函数会将被使用的文件标识符写入这个数组。

记住一般来说：

pipefd[0]为写端。

pipefd[1]为读端。

五、管道的特点

管道是单向通信的
管道的本质是文件，符合Linux下一切皆文件的设计理念。因为fd的生命周期是随进程的，所以管道的生命周期是随进程的。
通常需要有血缘关系的进程进行管道通信，比如：父子、兄弟、爷孙。因为这样才能继承指向同一个匿名管道的指针。与之相对的有命名管道，后续会详细介绍。
在管道通信中，写入的次数不一定与读取的次数，不是强相关的。

以下面这个为例子：

        while(true)
        {
            char a= 'x';
            
            write(pipefd[1],&a,1);
        }

这个是写端的代码。一次写入一个x。

    while(true)
    {
        int n=read(pipefd[0],buffer,sizeof buffer-1);
        if(n>0)
        {
            buffer[n]='\0';
            std::cout<<"child give me message:"<<buffer<<std::endl;
        }
    }

这个是读端的代码。

这样的运行结果是：

如图所示：可以看出，有时候写端写了很多次才会读，有时候写端写了三次就读取数据了。

这说明，一个进程重载读取管道中数据的时候是一次将管道中数据的数据全部读取出来的。而且我们也看得出读端的速度比写端的慢很多。

5.具有一定的协同能力，让reader和writer能够按照一定的步骤通信——自带的同步机制。

六、4中场景

如果我们read了所有的管道数据，如果对方不发，我就只能等待。
如果write把管道写满了，就不能继续写了。
如果我们关闭了写端，读取完管道数据，然后再读就会返回0，表明读到了文件结尾。
写端一直写，但是把读端关闭，os就会把进行写的程序（通过信号）直接杀死，因为os不会维护一个没有意义的进程。（没有读端，写端也就没有了意义了）。

场景三实例讲解：

            char a[]="abcdefg";
            write(pipefd[1],a,sizeof(a));
            sleep(3);
            close(pipefd[1]);

这里是负责写入的进程，对管道进行了写入，并在写入后3s关闭写端。

    while(true)
    {
        int n=read(pipefd[0],buffer,sizeof buffer-1);
        if(n>0)
        {
            buffer[n]='\0';
            std::cout<<"child give me message:"<<buffer<<std::endl;
        }
        else if(n==0)
        {
            std::cout<<"我读到了文件结尾"<<std::endl;
            break;
        }

    }

这里是负责读取的父进程，当读取到文件结尾时就爱给你退出进程。

一下是运行结果：