linux：进程间通信之管道

进程间通信的目的：

1.数据传输：一个进程需要将它的数据发送给另一个进程；
2.资源共享：多个进程之间共享同样的资源；
3.通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知进程）；
4.进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

什么是管道

管道是UNIX中最古老的进程间通信的形式

我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”，其实管道就是一块操作系统给我们的内存，通信时需要一个媒介，而管道就是这个媒介，我们说话时，空气把我们的声音给传播给另一个人，从而人和人之间可以进行通信，而管道就好比是空气，它是辅助进程与进程之间进行通信的

管道的分类

匿名管道

头文件：#include<unistd.h>
功能：创建一个无名就是匿名的管道
原型:int pipe(fd[2]);
参数说明：
fd：文件描述符数组，其中fd[0]表示读端，fd[1]表示写端
返回值：
成功：返回0
失败：返回错误代码

匿名管道的读写规则

1.如果所有管道写端对应的文件描述符被关闭，则read返回0；
2.如果所有管道读端对应的文件描述符被关闭，则write操作后产生信号SIGPIPE，进而可能导致write进程退出

匿名管道特点

1.只用用于具有共同祖先的进程（后者具有亲缘关系的进程）之间进行通信，通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道

2.管道提供流式服务
  （1）面向字节流(TCP)(即就是流式服务）--->比如写一个数据，写了10k，可一次读2k，分为5次读完，也可以一次性读完，读10k
   (2)面向数据报(UDP）--->写多少读多少，例写10k，一次必须读完，即就是一次性读10k

3.一般而言，进程退出，管道释放，所以管道的生命周期随进程

4.一般而言，内核会对管道操作进行同步与互斥（此时的同步与互斥就是：写满了就不写了，读完了就不读了）
ps：这里同步与互斥也可理解为就是阻塞式等待

5.管道是半双工的，数据只能向一个方向流动，需要双方通信时，需要建立起两个管道

示例

1.从键盘读取数据，写入管道，读取管道的内容，然后把数据输出到屏幕

代码：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)

int main()
{
    int fd[2];
    char buf[100];
    int len;
    if(pipe(fd)==-1)
        ERR_EXIT("pipe");
    //从键盘读取数据
    while(fgets(buf,100,stdin))
    {
        len=strlen(buf);
        //write to pipe
        if(write(fd[1],buf,len) != len)
            ERR_EXIT("write pipe");
        memset(buf,0x00,sizeof(buf));//把buf置空
        //read from pipe
        if(read(fd[0],buf,len)<0)
            ERR_EXIT("read pipe");
        //write to stdout
        if(write(1,buf,len)<0)
            ERR_EXIT("write stdout");
    }
    close(fd[1]);
    close(fd[0]);
    return 0;
}

运行结果：

2.用fork()来共享管道原理

代码：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)

int main()
{
    const char*msg="hello fork";
    int len=strlen(msg);
    //打开匿名管道
    int fd[2];
    if(pipe(fd)<0)
        ERR_EXIT("pipe");
    //fork子进程
    pid_t pid=fork();
    if(pid == -1)
        ERR_EXIT("fork");
    //子进程写
    if(pid==0)
    {
        close(fd[0]);
        write(fd[1],msg,len);
        close(fd[1]);
        exit(EXIT_FAILURE);
    } 
    //父进程读
    if(pid>0)
    {
        char buf[100];
        close(fd[1]);
        read(fd[0],buf,len);
        printf("buf:%s\n",buf);
        close(fd[0]);
        exit(EXIT_SUCCESS);
    }
    return 0;
}

运行结果：

命名管道

创建命名管道

1.命令（从命令行上创建）：mkfifo filename
2.函数(从程序里创建）：int mkfifo(const char*filename,mode_t mode)
例子（创建命名管道）
int main()
{
 int mkfifo("pipename",0644);
 return 0;
}

命名管道是一种特殊类型的文件

命名管道的打开规则

如果当前打开操作是为读而打开FIFO时
O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO
O_NONBLOCK enable：立刻返回成功
如果当前打开操作是为写而打开FIFO时
O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO
O_NONBLOCK enable：立刻返回失败，错误码为ENXIO

示例

1.用命名管道实现文件拷贝

代码：
（1）把一个已经存在文件里的内容拷贝到管道中

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)

int main()
{
    int outfd=0;
    int infd=0;
    //创建管道，并打开
    if(mkfifo("pipe",0644))
    {
        outfd=open("pipe",O_WRONLY);
        if(infd<0)
            ERR_EXIT("open pipe");
    }
    //打开文件
    infd=open("file",O_RDONLY);
    if(infd<0)
        ERR_EXIT("open file");
    //把文件中的内容拷贝到管道中
    char buf[1024];
    ssize_t r=read(infd,buf,sizeof(buf));
    if(r>0)
        write(outfd,buf,r);
    else
        ERR_EXIT("read");
    close(infd);
    close(outfd);
    return 0;
}

（2）把管道中的数据拷贝到一个新文件中

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)

int main()
{
    int infd=0;
    int outfd=0;
    //创建并打开一个新文件
    outfd=open("newfile",O_WRONLY|O_CREAT|O_TRUNC,0644);
    if(outfd<0)
        ERR_EXIT("open newfile");
    //读出管道中的内容
    infd=open("pipe",O_RDONLY); 
    if(infd<0)
        ERR_EXIT("open pipe");
    char buf[1024];
    ssize_t r=read(infd,buf,1024);
    //把读出的信息保存在新文件中
    if(r>0)
    {
        write(outfd,buf,r);
    }
    close(infd);
    close(outfd);
    return 0;
}

运行结果：
旧文件：

新文件：

从而，我们实现了文件拷贝

2.使用命名管道实现client与server之间的通信

代码：
（1）客户端给服务器发送消息

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)

int main()
{
    //打开服务器创建好的管道
    int infd=open("mypipe",O_WRONLY);
    if(infd<0)
        ERR_EXIT("open");
    while(1)
    {
        //从键盘读出信息
        printf("please enter:>  ");
        fflush(stdout);
        char buf[1024];
        ssize_t r=read(0,buf,sizeof(buf)-1); 
        //把读到的信息输入到管道中
        if(r>0)
        {
            buf[r]=0;
            write(infd,buf,r);
        }
        else
            ERR_EXIT("read");
    }
    close(infd);
    return 0;
}

（2)服务器端读取客户端发的消息

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#define ERR_EXIT(m)\
    do\
{\
    perror(m);\
    exit(EXIT_FAILURE);\
}while(0)

int main()
{
    int infd=0;
    //创建管道，如果管道已经存在，那就打开管道
    if(mkfifo("mypipe",0644)<0)
    {
        infd=open("mypipe",O_RDONLY);
        if(infd <0)
            ERR_EXIT("open mypipe");
    }
    while(1)
    {
        //从管道中读出客户端写入的信息
        printf("please wait......\n");
        char buf[1024];
        ssize_t r=read(infd,buf,sizeof(buf)-1);
        //输出读到的信息
        if(r>0)
        {
            printf("client say:> %s",buf);
        }
        else if(r==0)
        {
            printf("client now quit\n");
            exit(EXIT_SUCCESS);
        }
        else
            ERR_EXIT("read");
    }
    close(infd);
    return 0;
}

运行结果：
客户给服务器发消息：

服务器收到客户发的消息：

匿名管道与命名管道的区别

1.匿名管道由pipe函数创建并打开
2.命名管道由mkfifo函数（或者命令：mkfifo filename）创建，打开用open函数
3.FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创建与打开的方式不同，一旦这些工作完成之后，它们具有相同的意义