Linux进程间通信：管道

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

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

进程是程序的动态实例。

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

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

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

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

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

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

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

进程间通过共享的竞争：

特点：

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

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

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

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

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

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

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

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

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

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

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; 
}

运行结果：

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

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 }

运行结果：

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 }

运行结果：

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 }

运行结果：

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

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

本文出自 “剩蛋君” 博客，请务必保留此出处http://memory73.blog.51cto.com/10530560/1763416