ipc通信之一（管道）

前言

在很久以前，进程间通信方式，都是通过文件。这种方式有个缺点：效率（速度）太低了。
但是这种方式有一个天大的好处：简单，不需要额外 API函数支持（直接利用文件系统的 API 操作）
因为弊端所有需要改进，首先问题存在于：文件内容是在外设上面，文件系统上====>访问效率低。
管道：管道文件，它的文件内容是在内核/内存中

管道

：分为两种

pipe
无名管道

fifo
有名管道

无名管道：pipe

它在文件系统中没有名字（ inode ），它的内容存放在内核中，访问pipe的方式是通过文件系统的 API（read/write） 。
它不能用 open ，但是 read/write 有需要一个文件描述符。所以创建这个pipe的时候，就必须要返回一个文件描述符！！！！
pipe 在创建的时候，在内核中开辟一块区域作为缓冲区，作为pipe的文件的内容区域的存储空间，同时返回两个文件描述符（一个是用来读，一个用来写）

它有如下特点：

pipe 有两端，一端用于写，一端用于读。
按顺序读，不支持 lseek 光标偏移。
内容读走，就莫有了。
pipe（无名管道）随内核持续性。

pipe的 API
创建pipe管道：

/* on all othe r architectures */
int pipe(int pipefd[2]);
/*
@描述：
创建pipe管道
pipe用于在内核 中创建一个无名管道
pipefd用来保存创建好的无名管道的文件描述符， pipe创建管道， 默认“阻塞方式”
apipefd:
int类型数组， 表 示管道文件的描述符
pipefd[0] 表示读端文件描述符
pipefd[1] 表 示写端文件描述符
@return:
成功返回0,失败返回-1, 同时errno被设置。
*/

关闭pipe时候，需要注意， 要先关闭写端， 再关闭读端

pipe （无名管道）只能用于有亲缘关系的进程间通信，它为什么有这个限制？
因为它没有名字
假设它如果在文件系统中有个一个名字 “ inode ”它就可以用于任意进程间的通信

通过无名管道来进行父进程与子进程之间的通信

#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
    // 创建pipe管道文件
    int pipefd[2]={0};
    if(pipe(pipefd) == -1)
    {
        return -1;
    }

    // 创建子进程进行通信
    pid_t pid = fork();

    if(pid == 0)
    {
        while(1)
        {
            char buf[2]={0};
            printf("PID<%d>Enter:",pid);
            scanf("%s",buf);
            if(buf[0] == 'e')
            {
                write(pipefd[1],"e",1);
                close(pipefd[1]);
                return 0;
            }

            write(pipefd[1],buf,1);
        }
    }
    else if(pid > 0)
    {
        while(1)
        {
            char buf[2]={0};
            read(pipefd[0],buf,1);
            if(buf[0] == 'e')
            {
                close(pipefd[0]);
                return 0;
            }

            printf("PID<%d>RECV:%s\n",pid,buf);
        }
    }


    return 0;
}

有名管道：fifo

fifo 是在 pipe 基础上，给它在文件系统中创建一个 inode （它会在文件系统中有一个名字），但是fifo 文件的内容却是在内核中！！！！
fifo 的文件名随文件系统持续性
fifo 的文件内容存在于内核，随内核持续性
fifo 同 pipe 一样，除了 fifo 在文件系统中有一个文件名外。

fifo 的API
创建fifo 文件

MKFIFO(3) Linux Programmer's Manual MKFIFO(3)
NAME
mkfifo, mkfifoat - make a FIFO special file (a named pipe)
SYNOPSIS
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
/*
@描述：
在文件系统中创建一个fifo(有名管道)文件
@pathname：
需要创建的fifo文件的名字
@mode：
fifo文件的权限
1）宏值设置：
S_IRUSR
S_IWUSR
S_IXUSR
...
2）八进制：
0777
0774
0665
...
@return:
成功返回0，失败返回-1，同时errno被设置。
*/

注意： FIFO 特殊文件（命名管道）类似于管道，只是它是作为文件系统的一部分访问的。它可以通过多个进程打开以进行读取或写入。当进程通过 FIFO 交换数据时内核在内部传递所有数据，而不将其写入文件系统。

因此， FIFO 特殊文件没有内容在文件系统上；文件系统条目只是作为一个参考点，这样进程就可以访问管道使用文件系统中的名称。内核为至少一个进程打开的每个 FIFO 特殊文件保留一个管道对象。

这个必须先打开 FIFO 的两端（读取和写入），然后才能传递数据。通常，打开 FIFO 一端直到另一端也被打开。进程可以在非阻塞模式下打开 FIFO 。在Linux下，打开 FIFO 进行读写操作在阻塞和非阻塞模式下都会成功。

阻塞的读/写 ：
读的时候，如果没有数据，则read会阻塞
写的时候，如果没有空间，则write会阻塞
非阻塞的读/写：
读的时候，如果没有数据，则立即返回，设置对应错误码 写的时候，如果没有空间，则立即返回，设置对应错误码

在使用open的时候，默认是阻塞方式，非阻塞则需要或上一个宏：NONBLOCK

fifo_recieve.cpp

#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>



int main()
{

    mkfifo("./fifo",0777);
    int data = -1;
    int fifo_id = open("./fifo",O_RDONLY);
    if(fifo_id == -1)
    {
        perror("");
        return -1;
    }
    while(1)
    {
        read(fifo_id,&data,sizeof(data));//打开有名管道读端
        if(data == -1)
            break;
        printf("data:%d\n",data);
    }

    close(fifo_id);
    return 0;
}

fifo_send.cpp

#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>



int main()
{
    int data = -1;
    int fifo_id = open("./fifo",O_WRONLY);
    if(fifo_id == -1)
    {
        perror("");
        return -1;
    }
    while(1)
    {
        scanf("%d",&data);
        write(fifo_id,&data,sizeof(data));//打开有名管道写端
        if(data == -1)
            break;
    }

    close(fifo_id);
    return 0;
}