Linux管道通信

管道通信：
1.1 无名管道概述
管道(pipe)又称无名管道。
无名管道是一种特殊类型的文件，在应用层体现为两个打开的文件描述符。
任何一个进程在创建的时候，系统都会 给他分配4G的虚拟内存，分为3G的用户空间和1G的内核空间，内核空间是所有进程公有的，无名管道就是创建在内核空间的，多个进程知道同一个无名管道的空间，就可以利用他来进行通信

无名管道虽然是在内核空间创建的，但是会给当前用户进程两个文件描述符，一个负责执行读操作，一个负责执行写操作；
管道是最古老的UNIX IPC方式，其特点是:
1、半双工，数据在同一时刻只能在一个方向上流动。
2、数据只能从管道的一端写入，从另一端读出。
3、写入管道中的数据遵循先入先出的规则。
4、管道所传送的数据是无格式的，这要求管道的读出方与写入方必须事先约定好数据的格式，如多少字节算一个消息等。
5、管道不是普通的文件，不属于某个文件系统，其只存在于内存中。
6、管道在内存中对应一个缓冲区。不同的系统其大小不一定相同。
7、从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据。
8、管道没有名字，只能在具有公共祖先的进程之间使用
管道创建函数：
创建管道可以通过调用 pipe 来实现，下表 8.1 列出了 pipe 函数的语法要点。
注意：
一个管道共享了多对文件描述符时，若将其中的一对读写文件描述符都删除，则该管道就失效。

功能：创建一个有名管道，返回两个文件描述符负责对管道进行读写操作；
管道创建实例：

#include<unistd.h>
#include<errno.h>
#include<stdio.h>
#include<stdlib.h>
int main()
{
   
  int pipe_fd[2];
  //创建一无名管道
  if(pipe(pipe_fd)<0)
  {
   
     printf("pipe creat error\n");
     return -1;
   }
   else
      printf("pipe creat success\n");
    //关闭管道描述符
    close(pipe_fd[0]);
    close(pipe_fd[1]);
}

管道读写：
1．管道读写说明
用pipe函数创建的管道两端处于一个进程中，由于管道是主要用于在不同进程间通信的，因此这在实际应用中没有太大意义。实际上，通常先是创建一个管道，再通过 fork()函数创建一子进程，该子进程会继承父进程所创建的管道，这时，父子进程管道的文件描述符对应关系如图所示：

这时，父子进程分别拥有自己的读写的通道，为了实现父子进程之间的读写，只需把无关的读端或写端的文件描述符关闭即可。例如在图 8.5 中把父进程的写端 fd[1]和子进程的读端 fd[0]关闭。这时，父子进程之间就建立起了一条“子进程写入父进程读”的通道。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
int main(int argc,char const *argv[])
{
   
  //使用pipe创建一个无名管道
  int fd_pipe[2];
  if(pipe(fd_pipe) == -1)
  {
   
     perror("fail to pipe");
     exit(1);
   }
   printf("fd_pipe[0] = %d\n",fd_pipe[0]);
   printf("fd_pipe[1] = %d\n",fd_pipe[1]);
   //对无名管道执行读写操作
   //由于无名管道给当前用户进程两个文件描述符，所以只要操作这两个文件
   //描述符就可以操作无名管道，所以通过文件IO中的read和write函数对无名管道进行操作
   //通过write函数向无名管道中写入数据
   //fd_pipe[1]负责执行写操作
   //如果管道中有数据，再次写入的数据会放在之前数据的后面，不会把之前的数据替换
   if(write(fd_pipe[1],"hello word",11) == -1)
   {
   
      perror("fail to write");
      exit(1);
    }
    write(fd_pipe[1],"nihao beijing",strlen("nihao beijing")+1);
    //通过read函数从无名管道中读取数据
    //fd_pipe[0]负责执行读操作
    //读取数据时，直接从管道中读取指定个数的数据，如果管道中没有数据了，则read函数会阻塞等待
    char buf[32]="";
    ssize_t bytes;
    if((bytes = read(fd_pipe[0],buf,20)) == -1)
    {
   
       perror("fail to read");
       exit(1);
    }
    printf("buf = [%s]\n",buf);
    printf("bytes = %ld\n",bytes);
    bytes = read(fd_pipe[0],buf,sizeof(buf));
    printf("buf = [%s]\n",buf);
    printf("bytes = %ld\n",bytes);
    bytes = read(fd_pipe[0],buf,sizeof(buf));
    printf("buf = [%s]\n",buf);
    printf("bytes = %ld\n",bytes);
}  

无名管道实现进程间通信：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
//使用无名管道实现父子间进程间的通信
//由于无名管道创建之后给当前进程两个文件描述符，所以如果是完全不相关的进程
//无法获取同一个无名管道的文件描述符，所以无名管道只能在具有亲缘关系的进程间通信
int main(int argc,char *argv[])
{
   
  //创建一个无名管道
  int pipefd[2];
  if(pipe(pipefd) == -1)
  {
   
      perror("fail to pipe");
      exit(1);
   }
   //使用fork函数创建子进程
   pid_t pid;
   pid = fork();
   if(pid<0)
   {
   
      perror("fail to fork");
      exit(1);
    }
    else if(pid >0)//父进程
    {
   
       //父进程负责给子进程发送数据
       char buf[128] = {
   };
       while(1)
       {
   
           fgets(buf,sizeof(buf),stdin);
           buf[strlen(buf) - 1] = '\0';
           if(write(pipefd[1],buf,sizeof(buf)) == -1)
           {
   
              perror("fail to write");
              exit(1);
            }
         }
     }
     else//子进程
     {
   
        //子进程接收父进程的数据
        char buf[128] = "";
        while(1)
        {
   
           if(read(pipefd[0], buf ,sizeof(buf)) == -1)
           {
   
              perror("fail to read");
              exit(1);
            }
            printf("from parent: %s\n",buf);
          }
      }
      return 0;
}

注意：
利用无名管道实现进程间的通信，都是父进程创建无名管道，然后再创建子进程，子进程继承父进程的无名管道的文件描述符，然后父子进程通过读写无名管道实现通信；
无名管道的读写规律
读写端都存在，只读不写
案例：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main(int argc,char const *argv[])
{
   
   int pipefd[2];
   if(pipe(pipefd) =