提到进程间通信,我们需要先了解一下进程是什么:

    其实在Linux下,早期的Linux为了实现多个程序之间的交替操作,出现了进程的概念。为的就是维护操作系统整个的运行逻辑。并发就是进程间的交替执行。

进程是程序的动态实例。

进程并发运行的环境中,多个进程之间存在如下竞争和合作的关系:

-          进程中的资源争用(间接作用)

当并发进程竞争使用同一个资源时,它们之间就会发生冲突。为了避免冲突,当一个进程获得资源时,另一个进程必须等待。这种情况需要通过互斥机制来解决。

-          进程间通过共享的合作(间接作用)

一个进程等待另一个进程的执行,并以另一个进程的执行结果作为本进程的执行条件,就形成了同步机制

-          进程间通过通信的合作(直接作用)

进程间还可以通过通信进行合作,同性提供了同步和协调各种活动的方法。如操作系统提供的通信功能。

进程间通过共享的竞争:

特点:

1.       每个进程不知道其他进程的存在

2.       两个或者和更多的进程在各自的执行过程中需要访问相同的资源(IO设备、存储器、CPU)

3.       进程之间没有信息交互

每个进程在创建只时都会创建一个PCB,进程控制块。每个进程都认为自己拥有了世界(也就是独占所有的虚拟内存),实际上不是的。他们自己是子认为自己存在。但是是其他进程在睡眠/等待罢了,所以每个进程都认为自己是独立的。

    那么,作为一个操作系统,一个人(进程)是无法维护整个世界的和平(操作系统的逻辑/稳定),那么肯定需要合作,但是当前他们只认为整个世界只有一个,那该怎么办?


所以进程间通信就出来了,将需要进行交流的内容存储在一个指定的文件中。


通信:因为进程有强大独立性,当想把自己数据交给另一个进程,需要通信,将进程之间的沟通信息保存在约定好的某个文件中。

通信本质:让不同进程看到相同资源,通过约定好的方法进行寻找,调用,添加,删除。

wKioL1cIv3DC398KAAA9RvvYpoI673.png (476×236)

想到通信:在现实生活中我们传输物质最常用的就是管子呗。所以开发系统的人聪明,就用管道进行通信吧:

匿名管道:管道:通过某种机制传递资源(数据),匿名管道只适用于有血缘关系的进程,一般用于父,子进程通信。

a.创建管道

b.创建子进程

c.父,子进程关闭自己不需要的文件描述符

注意:匿名管道提供单向通信,父读子写或父写子读,若要实现双向通信,可再创建一个管道。

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<stdlib.h>
int main()
{
    int _pipefd[2]={-1,-1};
    int ret=pipe(_pipefd);
    if(ret==-1)
    {
        perror("pipe");
        return 2;
    }
    pid_t id=fork();
    if(id<0)
    {
        perror("fork");
        return 2;
    }
    else if(id==0)
     {
        close(_pipefd[0]);
        char buf[]="hello world";
        int count=5;
        while(count--)
        {
            write(_pipefd[1],buf,strlen(buf));
            sleep(1);
        }
    }
    else
     {  
       close(_pipefd[1]);
       char buf[1024]={0};
       while(1)
        {
          memset(buf,'\0',sizeof(buf));
          ssize_t _size=read(_pipefd[0],buf,sizeof(buf)-1);
          if(_size>0)
          {
               buf[_size]='\0';
               printf("buf:%s\n",buf);
          }    
        }
    }
    return 0; 
}

运行结果:wKioL1cJ3ArzNzmwAAAdw1y-BuE190.png

使用管道需注意以下四种情况:

1.如果所有指向管道写端的文件描述符都关闭了仍然有进程从管道的读端读数据,那么管道中剩余的数据都被读取后,再次read会返回0,就像读到文件末尾一样。

 1 #include<stdio.h>
  2 #include<string.h>
  3 #include<unistd.h>
  4 #include<sys/types.h>
  5 #include<stdlib.h>
  6 int main()
  7 {
  8     int _pipefd[2]={-1,-1};
  9     int ret=pipe(_pipefd);
 10     if(ret==-1)
 11     {
 12         perror("pipe");
 13         return 2;
 14     }
 15
 16     pid_t id=fork();
 17     if(id<0)
 18     {
 19         perror("fork");
 20         return 2;
 21     }
 22     else if(id==0)
 23      {
 24         close(_pipefd[0]);
 25         char buf[]="hello world";
 26         int count=5;
 27         int i=0;
 28         while(count--)
 29         {
 30             if(i==3)
 31             {
 32                 printf("I want sleep\n");
 33                 break;
 34             }
 35             write(_pipefd[1],buf,strlen(buf));
 36             sleep(1);
 37             i++;
 38         }
 39         close(_pipefd[0]);
 40     }
 41     else
 42     {
 43         close(_pipefd[1]);
 44         char buf[1024]={0};
 46         while(1)
 47         {
 48             memset(buf,'\0',sizeof(buf));
 49             ssize_t _size=read(_pipefd[0],buf,sizeof(buf)-1);
 50             if(_size>0)
 51             {
 52                   buf[_size]='\0';
 53                 printf("buf:%s\n",buf);
 54             }
 55         }
 56     }
 57     return 0;
 58 }

运行结果:wKiom1cJ3Quywia8AAAfDhjFF5M095.png

2.如果有指向管道写端的文件描述符没关闭,持有管道写端的进程也没有向管道中写数据,这时有进程从管道读端读数据,那么管道中剩余的数据都被读取后,再次read会阻塞,直到管道中有数据可读了才读取数据并返回。

1 #include<stdio.h>
  2 #include<sys/wait.h>
  3 #include<string.h>
  4 #include<unistd.h>
  5 #include<sys/types.h>
  6 #include<stdlib.h>
  7 int main()
  8 {
  9     int _pipefd[2]={-1,-1};
 10     int ret=pipe(_pipefd);
 11     if(ret==-1)
 12     {
 13         perror("pipe");
 14         return 2;
 15     }
 16 
 17     pid_t id=fork();
 18     if(id<0)
 19     {
 20         perror("fork");
 21         return 2;
 22     }
 23     else if(id==0)
 24     {
 25         close(_pipefd[0]);
 26         char buf[]="hello world";
 27         int count=5;
 28         int i=0;
 29         while(count--)
 30         {
 31              if(i==3)
 32              {
 33                   printf("I want sleep\n");
 34                   sleep(10);
 35              }
 36              write(_pipefd[1],buf,strlen(buf));
 37              sleep(1);
 38              i++;
 39         }
 40         close(_pipefd[0]);
 41     }
 42     else
 43     {
 44         close(_pipefd[1]);
 45         char buf[1024]={0};
 46         while(1)
 47         {
 48             memset(buf,'\0',sizeof(buf));
 49             ssize_t _size=read(_pipefd[0],buf,sizeof(buf)-1);
 50             if(_size>0)
 51             {
 52                 buf[_size]='\0';
 53                 printf("buf:%s\n",buf);
 54             }
 55         }
 56     }
 57     return 0;
 58 }

运行结果:

wKiom1cJ4Kvgg9x6AAAbfCqvGOo473.png

wKioL1cJ4V3C8lCNAAApNxzkLCc405.png

3.如果所有指向管道读端的文件描述符都关闭了,这时有进程向管道的写端write,那么该进程会收到信号SIGPIPE,通常会导致进程异常终止

 1 #include<stdio.h>
  2 #include<sys/wait.h>
  3 #include<string.h>
  4 #include<unistd.h>
  5 #include<sys/types.h>
  6 #include<stdlib.h>
  7 int main()
  8 {
  9     int _pipefd[2]={-1,-1};
 10     int ret=pipe(_pipefd);
 11     if(ret==-1)
 12     {
 13         perror("pipe");
 14         return 2;
 15     }
 16 
 17     pid_t id=fork();
 18     if(id<0)
 19     {
 20         perror("fork");
 21         return 2;
 22     }
 23     else if(id==0)
 24     {
 25         close(_pipefd[0]);
 26         char buf[]="hello world";
 27         int count=5;
 28         while(count--)
 29         {
 30              write(_pipefd[1],buf,strlen(buf));
 31              sleep(1);
 32         }
 33         close(_pipefd[0]);
 34     }
 35     else
 36     {
 37         close(_pipefd[1]);
 38         char buf[1024]={0};
 39         int i=5;
 40         while(i--)
 41         {
 42             if(i==3)
 43             {
 44                 close(_pipefd[0]);
 45             }
 46             memset(buf,'\0',sizeof(buf));
 47             ssize_t _size=read(_pipefd[0],buf,sizeof(buf)-1);
 48             if(_size>0)
 49             {
 50                 buf[_size]='\0';
 51                 printf("buf:%s\n",buf);
 52             }
 53         }
 54         int status=0;
 55         pid_t _pid=waitpid(id,&status,0);
 56         printf("waitpid: %d,return status:%d\n",id,status&0xff);
 57     }
 58     //printf("%d ,%d \n",_pipefd[0],_pipefd[1]);
 59     return 0;
 60 }

运行结果:

wKiom1cJ4uPxKfR-AAAV7bp7A-Y717.png

wKioL1cJ45XQWGQBAAAcliXwutM377.png

4.如果有指向管道读端的文件描述符没关闭,持有管道读端的进程也没有从管道中读数据,这时有进程向管道写端写数据,那么在管道被写满时再次write会阻塞,直到管道中有空位置了才写入数据并返回。(管道大小64K,65536个字节)。 

1 #include<stdio.h>
  2 #include<sys/wait.h>
  3 #include<string.h>
  4 #include<unistd.h>
  5 #include<sys/types.h>
  6 #include<stdlib.h>
  7 int main()
  8 {
  9     int _pipefd[2]={-1,-1};
 10     int ret=pipe(_pipefd);
 11     if(ret==-1)
 12     {
 13         perror("pipe");
 14         return 2;
 15     }
 16 
 17     pid_t id=fork();
 18     if(id<0)
 19     {
 20         perror("fork");
 21         return 2;
 22     }
 23     else if(id==0)
 24     {
 25         close(_pipefd[0]);
 26         char buf[]="hello world";
 27         int count=5;
 28         while(count--)
 29         {
 30              write(_pipefd[1],buf,strlen(buf));
 31              sleep(1);
 32         }
 33         close(_pipefd[0]);
 34     }
 35     else
 36     {
 37         close(_pipefd[1]);
 38         int status=0;
 39         pid_t wait=waitpid(id,&status,0);
 40         if(wait==id)
 41            printf("wait:%d,status:%d\n",wait,status);
 42     }
 43     return 0;
 44 }

总结匿名管道特点:

  1. 单向通信,适用于有血缘关系的进程通信。

  2. 管道提供流式服务(数据按序,不规定一次读多少)

  3. 管道内部有保证数据读完(完整性)。

  4. 进程间同步


但是匿名管道存在一个问题,就是只能够在亲缘关系的进程之间进行通信,如果我们2个独立的进程需要进行通信怎么办呢?聪明的开发者就实现了一个命名管道,命名管道就是显示的保存一个管道文件,名字,路径给你,你给我显示的保存读取数据在管道里面就好了。




命名管道


通过路径看到共同资源

  1. 在shell下交互的建立

  2. 调用函数

//client:
  1 #include<stdio.h>
  2 #include<unistd.h>
  3 #include<sys/types.h>
  4 #include<sys/stat.h>
  5 #include<stdlib.h>
  6 #include<string.h>
  7 #include<fcntl.h>
  8 int main()
  9 {
 10     umask(0);
 11     int fd=mkfifo("./.tmp",S_IFIFO|0666);
 12     if(fd<0)
 13     {
 14         perror("mkfifo");
 15         exit(1);
 16     }
 17     int _fd=open("./.tmp",O_WRONLY);
 18     if(_fd<0)
 19     {
 20         perror("mkfifo");
 21         exit(1);
 22     }
 23     while(1)
 24     {
 25     char buf[1024];
 26     fflush(stdout);
 27     memset(buf,'\0',sizeof(buf));
 28     printf("client:");
 29     size_t size=read(0,buf,sizeof(buf)-1);
 30     buf[size]='\0';
 31     write(_fd,buf,strlen(buf));
 32     }
 33     return 0;
 34 }
//server:
  1 #include<stdio.h>
  2 #include<string.h>
  3 #include<sys/types.h>
  4 #include<sys/stat.h>
  5 #include<fcntl.h>
  6 #include<unistd.h>
  7 #include<stdlib.h>
  8 int main()
  9 {
 10     int _fd=open("./.tmp",O_RDONLY);
 11     if(_fd<0)
 12     {
 13         perror("open");
 14         exit(1);
 15     }
 16     char buf[1024];
 17     while(1)
 18     {
 19         memset(buf,'\0',sizeof(buf));
 20         ssize_t _size=read(_fd,buf,sizeof(buf)-1);
 21         if(_size>0)
 22         {
 23             buf[_size]='\0';
 24             printf("server:%s",buf);
 25         }
 26         else
 27         {
 28             printf("read error\n");
 29             break;
 30         }
 31     }
 32     close(_fd);
 33     return 0;
 34 }
//Makefile编写:
 .PHONY:all
  2 all:client server
  3
  4 client:client.c
  5     gcc -o $@ $^
  6 server:server.c
  7     gcc -o $@ $^
  8 .PHONY:clean
  9 clean:
 10     rm -f client server .tmp

结果验证:打开两个终端,不同进程可以通信。

wKiom1cJ6I3QxxdhAAA85VcTtg0589.png