基础文章7：chap15 进程通信之管道 补充

存在一个问题 示例4：/*父进程与子进程之间交互：父进程向子进程写入from parent process，子进程向父进程写入from child process*/

参考文章

http://kenby.iteye.com/blog/1166111 Linux进程通信 之 管道

0.序

进程之间的通信 IPC：

     进程之间通信实际上就是进程之间进行消息传递。

     管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。 

     管道是Linux支持的最初Unix IPC形式之一，具有以下特点：

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

          只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）；

          单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。

      数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。

      管道两端用描述字fd[0]以及fd[1]来描述，管道的两端是固定了任务的。fd[0]只能用于读，称其为管道读端；另一端则只能用于写，由描述字fd[1]来表示，称其为管道写端。

1.两条重要规则：

当管道的一端被关闭后，下列两条规则起作用：

               1）当读一个写端被关闭的管道时，所有数据都被读取后，read返回0，用于指示达到了文件结束处。

               2）当写一个读端被关闭的管道，则产生信号SIGPIPE。如果忽略该信号或者捕捉该信号并从其处理程序返回，则write返回-1，errno设置为EPIPE。

2.从管道中读取数据

     1）如果管道的 写端不存在，读完管道中现有的所有数据后，则认为已经读到了数据的末尾，读函数返回的 读出字节 数为0；

     2）如果管道的写端存在并且有数据，那么就返回管道中现有的数据字节数或者请求的字节数。

          当管道的写端存在时，如果请求的字节数目大于PIPE_BUF，则返回管道中现有的数据字节数；如果请求的字节数目不大于PIPE_BUF，则返回管道中现有数据字节数（此时，管道中数据量小于请求的数据量）；或者返回请求的字节数（此时，管道中数据量不小于请求的数据量）。

     3）如果 管道没有数据，且管道的 写端口是打开状态，则读操作 被阻塞直到有数据写入为止。

3.向管道中写入数据：

      对于设置了阻塞标志的写操作：

          （1）当要写入的数据量 不大于PIPE_BUF时，linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数，则进入睡眠，直到当缓冲区中能够容纳要写入的字节数时，才开始进行一次性写操作。

          （2）当要写入的数据量 大于PIPE_BUF时，linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域，写进程就会试图向管道写入数据，写操作在写完所有请求写的数据后返回。

      对于没有设置阻塞标志的写操作：

          （1）当要写入的数据量 大于PIPE_BUF时，linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后，写操作返回。

          （2）当要写入的数据量 不大于PIPE_BUF时，linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数，写完后成功返回；如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数，则返回EAGAIN错误，提醒以后再写.

4.管道的局限性

管道的主要局限性正体现在它的特点上：

     只支持单向数据流；

     只能用于具有亲缘关系的进程之间；

     没有名字；

     管道的缓冲区是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；

     管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须事先约定好数据的格式，比如多少字节算作一个消息（或命令、或记录）等等；

有名管道以FIFO的文件形式存在于文件系统中。这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信

5.学习用例：

为了充分理解管道，现在又从网上找到部分详细用例 

示例1：

/*1 只有管道写端的引用计数变成0,才会关闭管道得写端. 2 进程结束后,自动关闭打开的文件 3 如果父进程先退出,而且没有调用wait等待子进程, 那么子进程就会变成僵死进程*/ #include <sys/wait.h> #include <stdio.h>   #include <unistd.h>   #include <stdlib.h>      int main(int argc, const char **argv)   {       int len;       pid_t pid;       int pfd[2];       char buffer[1024] = {0};          if (pipe(pfd) < 0) {           printf("pipe error\n");           exit(0);       }          if ((pid = fork()) < 0) {           printf("fork error\n");           exit(0);       }          if (pid == 0) {      /* 子进程 */           write(pfd[1], "hello\n", 6);   //        close(pfd[1]);           sleep(2);       } else {               /* 父进程 */           close(pfd[1]);           while ((len = read(pfd[0], buffer, 1023)) > 0) {               buffer[len] = '\0';               printf("len = %d, %s", len, buffer);           }           printf("read done\n");           wait(0);      /* 等待子进程退出才能看到效果 */       }       return 0;   }

示例2：

/* 如果父进程不关闭管道的写端, 即便子进程关闭了管道的写端, 还是会阻塞在read上 1）当读一个写端被关闭的管道时，所有数据都被读取后，read返回0，用于指示达到了文件结束处 这个程序可以很好地说明这一点，当注释掉parent中close(pfd[1])；后，程序就进入阻塞*/ #include <stdio.h>   #include <unistd.h>   #include <stdlib.h>   #include <sys/wait.h>   int main(int argc, const char **argv)   {       int len;       pid_t pid;       int pfd[2];       char buffer[1024] = {0};                if (pipe(pfd) < 0) {           printf("pipe error\n");           exit(0);       }          if ((pid = fork()) < 0) {           printf("fork error\n");           exit(0);       }          if (pid == 0) {      /* 子进程 */           close(pfd[1]);           while ((len = read(pfd[0], buffer, 1023)) > 0) {               buffer[len] = '\0';               printf("len = %d, %s", len, buffer);           }       } else {               /* 父进程 */           close(pfd[0]);         write(pfd[1], "hello\n", 6);   //        close(pfd[1]);           wait(0);       }       return 0;   }

示例3：

/* 当写一个读端被关闭的管道，则产生信号SIGPIPE。如果忽略该信号或者捕捉该信号并从其处理程序返回，则write返回-1，errno设置为EPIPE。 当用gdb运行时，可以发现当写一个读端被关闭的管道，会产生信号SIGPIPE*/ #include <sys/wait.h> #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <fcntl.h> #include <stdlib.h> #define MAXLINE 200 int main(void) {     int n;     int fd[2];     pid_t pid;     char line[MAXLINE];     if(pipe(fd) < 0)         printf("pipe error\n");     if((pid = fork()) < 0)      printf("fork error\n");     else if(pid > 0 ){         close(fd[0]);         while(1){           n =  write(fd[1],"hello,world",MAXLINE);           if(n <= 0){              printf("n <= 0\n");              break;           }           printf("parent n :%d\n",n);         }         waitpid(pid,0,0);    }else{         printf("child\n");         close(fd[1]);         n = read(fd[0],line,MAXLINE);         write(STDOUT_FILENO,line,n);         close(fd[0]);         printf("close read end in child\n");     }     exit(0); }

gdb运行结果

示例4：

/*父进程与子进程之间交互：父进程向子进程写入from parent process，子进程向父进程写入from child process*/ #include <sys/wait.h> #include <stdio.h>  #include <unistd.h>  #include <stdlib.h>    int main(int argc, const char **argv)  {      int pfd2[2];      pid_t pid;      int pfd1[2];      int n;     char buffer1[1024] = {0};  char buffer2[1024] = {0}       if ( (pipe(pfd1) < 0) || (pipe(pfd2) < 0)  ) {          printf("pipe error\n");          exit(0);      }        if ((pid = fork()) < 0) {          printf("fork error\n");          exit(0);      }        if (pid == 0) {      /* 子进程 */           close(pfd1[0]);          write(pfd1[1],"from child process",1024);          close(pfd1[1]);          close(pfd2[1]);          while((n = read(pfd2[0],buffer1,1024)) > 0 )               write(STDOUT_FILENO,buffer1,n);          exit(1);     } else {               /* 父进程 */                   close(pfd2[0]);          write(pfd2[1],"from parent process",1024);          close(pfd2[1]);          close(pfd1[1]);          while((n = read(pfd1[0],buffer2,1024)) > 0 )               write(STDOUT_FILENO,buffer2,n);          wait(0);     }      return 0;  }

运行结果：不知道为什么会出现两次from parent process

示例5：

#include <sys/wait.h> #include <stdio.h>  #include <unistd.h>  #include <stdlib.h>    int main(int argc, const char **argv)  {      int pfd2[2];      pid_t pid;      int pfd1[2];      int n;     char buffer1[1024] = {0},buffer2[1024]={0};        if ( (pipe(pfd1) < 0) || (pipe(pfd2) < 0)  ) {          printf("pipe error\n");          exit(0);      }        if ((pid = fork()) < 0) {          printf("fork error\n");          exit(0);      }        if (pid == 0) {      /* 子进程 */           close(pfd1[0]);          write(pfd1[1],"from child process",1024);          close(pfd1[1]);          close(pfd2[1]);          while((n = read(pfd2[0],buffer1,1024)) > 0 ){                 buffer1[n]='\0';                 printf("buffer1:%s\n",buffer1);                }          exit(1);     } else {               /* 父进程 */          close(pfd1[1]);          close(pfd2[0]);          write(pfd2[1],"from parent process",1024);          close(pfd2[1]);          while((n = read(pfd1[0],buffer2,1024)) > 0 ){                buffer2[n]='\0';                 printf("buffer2:%s\n",buffer2);                         }          wait(0);     }      return 0;  }

6.总结

     管道：用于进程间通信。

     管道有其局限性：1）半双工性 2） 只能在拥有共同祖先的进程间进行通信

     管道的读写操作：

          1）管道读操作：（1）正常读取  （2）读取写端关闭的通道，那么在读取完所有数据以后，会返回0，表示文件结束     

          2）管道写操作：（1）正常写        （2）写入读端关闭的通道，那么会产生信号SIGPIPE。如果忽略该信号或者捕捉该信号并从其处理程序返回，则write返回-1，errno设置为EPIPE。