center进程间通信center

进程间通信

文章目录

1.1进程间通信的概念

进程间通信就是进程之间进行信息的交换和传播

很重要的一句话：进程间通信的本质是让不同的进程看到同一根资源

1.2进程间通信的目的

• 数据传输：一个进程需要将自己的数据发生给其他的进程
• 资源共享：多个进程之间共用相同的资源
• 通知事件：一个进程需要向拎一个进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）
• 进程控制：有些进程希望完全控制另一个进程的执行（如debug进程)，此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变

1.3进程间通信的方式

• 管道（本文主讲） - 匿名管道pipe- 命名管道
• System V进程间通信（本文不涉及） - System V消息队列- System V共享内存- System V信号量
• POSIX进程间通信（本文不涉及） - 消息队列- 共享内存- 信号量- 互斥量- 条件变量- 读写锁

2.1管道的概念

管道是一种古老的进程间通信的形式

• 通常把一个进程连接到另一个进程的一个数据流称为一个“管道”

2.2匿名管道的介绍

匿名管道就是没有名字的管道，由函数pipe(int fd[2]) 创建，常用于具有亲缘关系的进程间进行通信，作为两个进程共享的资源，从而实现两个进程间的信息交换达到通信的目的。

2.2.1管道的5种特征4种情况

5种特征：

• 1.管道内部已经自动提供了同步与互斥机制（读和写只能一个进行另一个等待，不能同时进行）
• 2.如果打开文件的进程退出了，文件也会被释放掉（所有打开了某一文件的进程全部退出了，该文件的资源才会彻底释放掉）
• 3.管道是提供流式服务的（本文只是提及，知道有这么个东西即可，后续的博客应该会讲）
• 4.管道是半双工通信的（管道只能是单向通信的，例如父进程在进行写入数据到匿名管道，那么子进程就不能进行读取管道信息，必须等父进程写完了才可以进行读操作，也就是父子进程只能是其中一个对管道进行读或写操作，不能父子进程同时对管道进行读或者写操作！！！）
• 5.匿名管道适合具有血缘关系的进程进行进程间通信，常用于父子

4种情况：

• 1.（子或父）不write，（父或子）一直read，read阻塞
• 2.（子或父） 不read ，（父或子）一直write，write阻塞
• 3.write写完后关闭，read返回值为0
• read关闭，一直写，写方会被操作系统杀掉，写入无意义

2.3管道读写的规则说明

（fd_arrray[3] fd_array[4] 不理解的第三张图有解释）

通过pipe（int fd[2]）创建了管道后，再通过fork（）创建子进程

错误读写：

正确读写：

父进程读，子进程写的相关代码（本文主要代码，举例也是这在这段代码的基础上变换来的）：

#include<stdio.h>#include<stdlib.h>#include<unistd.h>#include<sys/wait.h>#include<sys/types.h>#include<string.h>intmain(){int fd[2];if(pipe(fd)<0){//创建管道perror("pipe!");//这个函数自带换行return1;}//printf("fd[0]\n",fd[0]);//printf("fd[1]\n",fd1]);//创建子进程
   
  pid_t id =fork();if(id==0){//child//子进程要做的是向管道里写数据 要把读端关闭 最后写完了再把写端关闭close(fd[0]);int count=10;constchar* str="hello father i am your child!\n";while(count){write(fd[1],str,strlen(str));//  printf("%s",str);
      count--;sleep(1);}close(fd[1]);exit(1);}elseif(id>0){//fatherclose(fd[1]);//父进程关闭写端，只进行读char buff[64];while(1){int ret=read(fd[0],buff,sizeof(buff));if(ret>0){
        buff[ret]='\0';printf("child send to father's message is:%s\n",buff);//   close(fd[0]);//  break;//这里不能直接就break 不然就是只读了一次 这里写了10次要一直读 直到读到了文件结尾才停止 才能读完}elseif(ret==0){printf("read file of end!\n");break;}else{perror("read");break;}}}else{//errorperror("fork!");return1;}int status=0;int ret=waitpid(id,&status,0);//阻塞式等待if(ret>0){printf("child is quit! single is:%d",status&0x7F);}return0;}

4种情况的分析：

第一种：（子或父）不write，（父或子）一直read，read阻塞

代码：

#include<stdio.h>#include<stdlib.h>#include<unistd.h>#include<sys/wait.h>#include<sys/types.h>#include<string.h>intmain(){int fd[2];int ret =pipe(fd);if(ret<0){perror("pipe");return-1;}

 pid_t id=fork();//创建子进程if(id==0){//childclose(fd[0]);//子进程关闭读端 使得其只能往管道中进行写入constchar* str="i\n";int count=5;while(count){if(count>=2)//count 大于等于2就写 否则就休眠{write(fd[1],str,strlen(str));
     count--;sleep(1);}else{sleep(1000);//子进程写两次就不写了 进行休眠 但是父进程一直在读 这样就会形成读堵塞}}//一直写 当不再打印count时说明管道的缓冲区写满了，此时的count就是管道的容量}elseif(id>0){//fatherclose(fd[1]);//关闭写端// sleep(1000);char arr[1000];while(1){int ret=read(fd[0],arr,sizeof(arr));if(ret>0)//读到了内容{
        arr[ret]='\0';printf("%s",arr);}elseif(ret==0){//读到了文件结尾printf("read end of file!\n");break;}else{//read error// perror("read");printf("read error!\n");break;}}}else{//errorperror("fork!");}int status=0;int s=waitpid(id,&status,0);//阻塞式等待if(s>0){printf("child quit!\n");}else{printf("wait error!");}printf("quit singal is:%d\n",ret&0x7F);return0;}

第二种：（子或父） 不read ，（父或子）一直write，write阻塞

代码：

#include<stdio.h>#include<stdlib.h>#include<unistd.h>#include<sys/wait.h>#include<sys/types.h>#include<string.h>intmain(){int fd[2];int ret =pipe(fd);if(ret<0){perror("pipe");return-1;}

 pid_t id=fork();//创建子进程if(id==0){//childclose(fd[0]);//子进程关闭读端 使得其只能往管道中进行写入constchar* str="i";//每次写一个字节int count=0;while(1){write(fd[1],str,strlen(str));
  count++;printf("%d\n",count);//写一次打印一次count }//一直写 当不再打印count时说明管道的缓冲区写满了，此时的count就是管道的容量}elseif(id>0){//fatherclose(fd[1]);//关闭写端sleep(1000);//直接让父进程休眠，就不会读取管道里的数据，让子进程一直往里写就行了char arr[1000];while(1){int ret=read(fd[1],arr,sizeof(arr));while(1){if(ret>0)//读到了内容{
        arr[ret]='\0';printf("%s",arr);}elseif(ret==0){//读到了文件结尾printf("read end of file!\n");break;}else{//read errorperror("read");break;}}}}else{//errorperror("fork!");}//等待子进程退出int status=0;int s=waitpid(id,&status,0);//阻塞式等待if(s>0){printf("child quit!\n");}else{printf("wait error!");}printf("quit singal is:%d\n",ret&0x7F);return0;}

运行结果-> 不再打印count 说明write阻塞了 测得管道缓冲区大小为65536个字节

结合文档 本机是3.几的版本 所以是65536个字节 得到证实

第三种：.write写完后关闭，read返回值为0

#include<stdio.h>#include<stdlib.h>#include<unistd.h>#include<sys/wait.h>#include<sys/types.h>#include<string.h>intmain(){int fd[2];int ret =pipe(fd);if(ret<0){perror("pipe");return-1;}

 pid_t id=fork();//创建子进程if(id==0){//childclose(fd[0]);//子进程关闭读端 使得其只能往管道中进行写入constchar* str="i\n";//每次写一个字节int count=5;while(count){write(fd[1],str,strlen(str));
     count--;sleep(1);}//重点close(fd[1]);//写完关闭 写端 父进程读的时候就会读到文件结尾 返回值为0exit(0);//子进程写完退出}elseif(id>0){//fatherclose(fd[1]);//关闭写端// sleep(1000);char arr[1000];while(1){int ret=read(fd[0],arr,sizeof(arr));if(ret>0)//读到了内容{
        arr[ret]='\0';printf("%s",arr);}elseif(ret==0){//读到了文件结尾printf("read end of file!\n");break;}else{//read error// perror("read");printf("read error!\n");break;}}int status=0;int s=waitpid(id,&status,0);//阻塞式等待if(s>=0){printf("child quit!\n");}else{printf("wait error! s:%d\n",s);}printf("quit singal is:%d\n",status&0x7F);return0;}else{//errorperror("fork!");}return0;}

运行结果：写端写完关闭 读端再读 读到文件结尾 read返回值为0

第四种：read关闭，一直写，写方会被操作系统杀掉，写入无意义

代码：

#include<stdio.h>#include<stdlib.h>#include<unistd.h>#include<sys/wait.h>#include<sys/types.h>#include<string.h>intmain(){int fd[2];int ret =pipe(fd);if(ret<0){perror("pipe");return-1;}

 pid_t id=fork();//创建子进程if(id==0){//childclose(fd[0]);//子进程关闭读端 使得其只能往管道中进行写入constchar* str="i\n";//每次写一个字节while(1){write(fd[1],str,strlen(str));sleep(1);}close(fd[1]);//写完关闭 写端 父进程读的时候就会读到文件结尾 返回值为0exit(0);}elseif(id>0){//fatherclose(fd[1]);//关闭写端close(fd[0]);//父进程直接关闭读端 不读取管道信息 子进程还在一直写 没有意义 操作系统会将其杀掉// sleep(1000);char arr[1000];while(1){int ret=read(fd[0],arr,sizeof(arr));if(ret>0)//读到了内容{
        arr[ret]='\0';printf("%s",arr);}elseif(ret==0){//读到了文件结尾printf("read end of file!\n");break;}else{//read error// perror("read");printf("read error!\n");break;}}int status=0;int s=waitpid(id,&status,0);//阻塞式等待if(s>=0){printf("child quit!\n");}else{printf("wait error! s:%d\n",s);}printf("quit singal is:%d\n",status&0x7F);return0;}else{//errorperror("fork!");}return0;}

运行结果：子进程被操作系统杀掉 因为父进程不会读 子进程写的没有意义 且子进程退出信号为13 SINPIPE

注意的点（重点）：

1.pipe()创建出来的管道是要传一个元素为二的数组的 fd[0] f[1]分别代表读和写端

2.既然创建子进程后要把父子进程的读或写端关掉一个，那么为什么不开始创建的时候父进程的读写端都是打开的呢？

实质上是为了让子进程继承下来，后面关掉一端，是因为管道只能是单向通信的

3.管道是自带同步与互斥机制的，这样就使得父子进程不能同时使用一块相同资源，子进程写的时候父进程不能读，只能等待子进程写完了才可以去读，即读写不能同时进行，否则会使得数据错乱。在多执行流下（父子）看到的同一份资源就是叫临界资源

4如果写端关闭，读端就会读到文件的结尾，返回0，代表文件结束

5.文件的生命周期随着进程的结束而结束，也就是说打开文件的进程退出了，文件也就会被释放掉，这里可能是多个进程都打开了某个文件，则所有打开此文件的进程都退出了此文件资源才会完全释放掉

6.管道提供流式服务且管道是半双工通信

7.匿名管道适合具有血缘关系的进程进行进程间通信，常用于父子