Linux基础篇 进程通信——管道

IPC(InterProcess Communication)进程间通信
每个进程各?自有不同的?用户地址空间,任何?一个进程的全局变量在另?一个进程中都看不到所以进 程之间要交换数据必须通过内核,在内核中开辟?一块缓冲区,进程1把数据从?用户空间拷到内核缓 冲区,进程2再从内核缓冲区把数据读?走,内核提供的这种机制称为进程间通信。

linux下进程间通信的几种主要?手段简介：
1 管道（Pipe）及有名管道（named pipe）：管道可?用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；
2 信号（Signal）：信号是比较复杂的通信?方式，用于通知接受进程有某种事件发?生，除了用于进程间通信外，进程还可以发送信号给进程本?身；linux除了?支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction（实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，?用sigaction函数重新实现了signal函数）；
3 报?文（Message）队列（消息队列）：消息队列是消息的链接表，包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区?大?小受限等缺点。
4 共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使?用，来达到进程间的同步及互斥。
5 信号量（semaphore）：主要作为进程间以及同一进程不同线程之间的同步手段。
6 套接口（Socket）：更为一般的进程间通信机制，可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的，但现在一般可以移植到其它类Unix系统上：Linux和System V的变种都支持套接字。

本篇文章先来学习下管道个命名管道。
管道是?一种最基本的IPC机制,由pipe函数创建:

#include <unistd.h>
int pipe(int filedes[2]);

调?用pipe函数时在内核中开辟一块缓冲区(称为管道)用于通信,它有一个读端一个写端,然后通过filedes参数传出给用户程序两个文件描述符,filedes[0]指向管道的读端,filedes[1]指向管道的写端(很好记,就像0是标准输?入1是标准输出一样)。所以管道在用户程序看起来就像一个打开的文件,通过read(filedes[0]);或者write(filedes[1]);向这个文件读写数据其实是在读写内核缓冲区。pipe函数调用成功返回0,调用失败返回-1。

我们来演示下Pipe的通信功能，首先
1. 父进程调?用pipe开辟管道,得到两个文件描述符指向管道的两端。
2. 父进程调?用fork创建?子进程,那么子进程也有两个文件描述符指向同一管道。
3. 父进程关闭管道读端,子进程关闭管道写端。父进程可以往管道里写,子进程可以从管道里读,管道是用环形队列实现的,数据从写端流入从读端流出,这样就实现了进程间通信。
代码如下：

#include<stdio.h>
  2 #include<unistd.h>
  3 #include<errno.h>
  4 #include<string.h>
  5 
  6 int main()
  7 {
  8     int _pipe[2];
  9     int ret=pipe(_pipe);
 10     if(ret==-1)//
 11     {
 12         printf("creat pipe error!errno code is:%d\n",errno);
 13         return 1;
 14     }
 15     pid_t id = fork();
 16     if(id<0)
 17     {
 18         printf("fork error!");
 19         return 2;
 20     }
 21     else if(id==0)//child
 22     {
 23         close(_pipe[0]);
 24         int i=0;
 25         char* _mesg_c=NULL;
 26         while(i<100)
 27         {
 28             _mesg_c="i im coder";
 29             write(_pipe[1],_mesg_c,strlen(_mesg_c)+1);
 30             sleep(1);
 31             i++;
 32         }
 33     }
 34   else{//father
 35        close(_pipe[1]);
 36        char _mesg[100];
 37        int j=0;
 38        while(j<100)
 39        {
 40            memset(_mesg,‘\0‘,sizeof(_mesg));
 41            read(_pipe[0],_mesg,sizeof(_mesg));
 42            printf("%s\n",_mesg);
43            j++;
 44        }
 45         }
 46 
 47     return 0;
 48 }

运行结果如下：

使?用管道有一些限制:
两个进程通过一个管道只能实现单向通信。比如上面的例子,父进程写子进程读,如果有时候也需要子进程写父进程读,就必须另开一个管道。
管道的读写端通过打开的?文件描述符来传递,因此要通信的两个进程必须从它们的公共祖先那?里继承管道?文件描述符。上?面的例子是父进程把?文件描述符传给子进程之后父子进程之间通信,也可以父进程fork两次,把?文件描述符传给两个子进程,然后两个子进程之间通信, 总之需要通过fork传递文件描述符使两个进程都能访问同一管道,它们才能通信。 也就是说，管道通信是需要进程之间有关系。
使?用管道需要注意以下4种特殊情况(假设都是阻塞I/O操作,没有设置O_NONBLOCK标志):
1. 如果所有指向管道写端的文件描述符都关闭了(管道写端的引?用计数等于0),而仍然有进程 从管道的读端读数据,那么管道中剩余的数据都被读取后,再次read会返回0,就像读到文件末尾一样。
代码和上面的代码类似，只是修改子进程中写入的循环条件，部分代码如下：

 else if(id==0)//child
 22     {
 23         close(_pipe[0]);
 24         int i=0;
 25         char* _mesg_c=NULL;
 26         while(i<10)
 27         {
 28             _mesg_c="i im coder";
 29             write(_pipe[1],_mesg_c,strlen(_mesg_c)+1);
 30             sleep(1);
 31             i++;
 32         }
            close(_pipe[1]);
 33     }

运行结果如下：

2. 如果有指向管道写端的文件描述符没关闭(管道写端的引用计数?大于0),而持有管道写端的 进程也没有向管道中写数据,这时有进程从管道读端读数据,那么管道中剩余的数据都被读取后,再次read会阻塞,直到管道中有数据可读了才读取数据并返回。
3. 如果所有指向管道读端的文件描述符都关闭了(管道读端的引?用计数等于0),这时有进程向管道的写端write,那么该进程会收到信号SIGPIPE,通常会导致进程异常终止。

#include <stdio.h>
  2 #include <unistd.h>
  3 #include <errno.h>
  4 #include <string.h>
  5 #include <sys/wait.h>
  6 void fun()
  7 {
  8     printf("zhongzhi\n");
  9 }
 10 int main()
 11 {
 12     signal(13,fun);
 13 int _pipe[2];
 14 int ret = pipe(_pipe);
 15 if(ret == -1){
 16 printf("create pipe error! errno code is : %d\n",errno);
 17 return 1;
 18 }
 19 pid_t id = fork();
 20 if( id < 0 ){
 21 printf("fork error!");
 22 return 2;
23 }else if( id == 0 ){ //child 
 24 close(_pipe[0]);
 25 int i =0;
 26 char *_mesg_c=NULL;
 27 while(i<20){
 28 if( i < 10 ){
 29 _mesg_c="i am child!";
 30 write(_pipe[1], _mesg_c, strlen(_mesg_c)+1);
 31 }
 32 sleep(1);
 33 i++;
 34 }
 35 }else{ //father 
 36 close(_pipe[1]);
 37 char _mesg[100];
 38 int j = 0;
 39 while(j<3){
 40 memset(_mesg, ‘\0‘, sizeof(_mesg));
 41 int ret = read(_pipe[0], _mesg, sizeof(_mesg));
 42 printf("%s : code is : %d\n",_mesg, ret);
 43 j++;
44 }
 45 close(_pipe[0]);
 46 sleep(10);
 47 if ( waitpid(id, NULL, 0)< 0)
 48 {
 49 return 3;
 50 }
 51 }
 52 return 0;
 53 }

运行结果如下：

4. 如果有指向管道读端的文件描述符没关闭(管道读端的引?用计数?大于0),?而持有管道读端的 进程也没有从管道中读数据,这时有进程向管道写端写数据,那么在管道被写满时再 次write会阻塞,直到管道中有空位置了才写?入数据并返回。
命名管道
1 概念
管道的一个不足之处是没有名字，因此，只能用于具有亲缘关系的进程间通信，在命名管道（named pipe或FIFO）提出后，该限制得到了克服。FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存储于文件系统中。命名管道是一个设备文件，因此，即使进程与创建FIFO的进程不存在亲缘关系，只要可以访问该路径，就能够通过FIFO相互通信。值得注意的是，FIFO(first input first output)总是按照先进先出的原则工作，第一个被写入的数据将?首先从管道中读出。
2 命名管道的创建与读写
Linux下有两种方式创建命名管道。一是在Shell下交互地建立一个命名管道，二是在程序中使?用系统函数建?立命名管道。Shell方式下可使用mknod或mkfifo命令，下面命令使用mknod创建了一个命名管道：mknod namedpipe创建命名管道的系统函数有两个：mknod和mkfifo。两个函数均定义在头?文件sys/stat.h，
函数原型如下：

#include <sys/types.h>
#include <sys/stat.h>
int mknod(const char *path,mode_t mod,dev_t dev);
int mkfifo(const char *path,mode_t mode);

函数mknod参数中path为创建的命名管道的全路径名：mod为创建的命名管道的模式，指明其存取权限；dev为设备值，该值取决于文件创建的种类，它只在创建设备文件时才会?用到。这两个函数调用成功都返回0，失败都返回－1。下面使用mknod函数创建了一个命名管道：

umask(0);
if (mknod("/tmp/fifo",S_IFIFO | 0666) == -1)
{
perror("mkfifo error");
exit(1);
}
umask(0);
if (mkfifo("/tmp/fifo",S_IFIFO|0666) == -1)
{
perror("mkfifo error!");
exit(1);
}

“S_IFIFO|0666”指明创建?一个命名管道且存取权限为0666，即创建者、与创建者同组的?用户、其他用户对该命名管道的访问权限都是可读可写（ 这?里要注意umask对生成的管道?文件权限的影响 ）。命名管道创建后就可以使用了，命名管道和管道的使用方法基本是相同的。只是使?用命名管道时，必须先调用open()将其打开。因为命名管道是一个存在于硬盘上的?文件，而管道是存在于内存中的特殊?文件。 需要注意的是，调用open()打开命名管道的进程可能会被阻塞。但如果同时用读写方式（O_RDWR）打开，则?一定不会导致阻塞；如果以只读方式（O_RDONLY）打开，则调?用open()函数的进程将会被阻塞直到有写方打开管道；同样以写?方式（O_WRONLY）打开也会阻塞直到有读?方式打开管道。
3、总结
mkfifo函数的作?用是在?文件系统中创建?一个?文件，该?文件?用于提供FIFO功能，即命名管道。
前边讲的那些管道都没有名字，因此它们被称为匿名管道，或简称管道。对?文件系统来说，
匿名管道是不可见的，它的作?用仅限于在?父进程和?子进程两个进程间进?行通信。?而命名管
道是?一个可见的?文件，因此，它可以?用于任何两个进程之间的通信，不管这两个进程是不
是?父?子进程，也不管这两个进程之间有没有关系。
下面我们通过程序演示下FIFO的功能
FIFO server端：

 1 #include<stdio.h>
  2 #include<sys/types.h>
  3 #include<sys/stat.h>
  4 #include<unistd.h>
  5 #include<fcntl.h>
  6 #include<string.h>
  7 
  8 #define _PATH_ "./file.tmp"
  9 #define _SIZE_ 100
 10 
 11 int main()
 12 {
 13     int ret=mkfifo(_PATH_,0666|S_IFIFO);
 14     printf("%d\n",ret);
 15     if(ret==-1)
 16     {
 17         printf("mkfifo error\n");
 18         return 1;
 19     }
 20     int fd=open(_PATH_,O_WRONLY);
 21     if(fd<0)
 22     {
23         printf("open file error!\n");
 24         return 1;
 25     }
 26     char buf[_SIZE_];
 27     memset(buf,‘\0‘,sizeof(buf));
 28     while(1)
 29     {
 30         scanf("%s",buf);
 31         int ret=write(fd,buf,sizeof(buf));
 32         if(ret<=0)
 33         {
 34             printf("raed end or error!\n");
 35             break;
 36         }
 37         printf("%s\n",buf);
 38         if(strncmp(buf,"quit",4)==0)
 39         {
 40             break;
 41         }
 42     }
 43     close(fd);
 44     return 0;
 45 }

FIFO client端：

 1 #include<stdio.h>
  2 #include<sys/types.h>
  3 #include<sys/stat.h>
  4 #include<unistd.h>
  5 #include<fcntl.h>
  6 #include<string.h>
  7 
  8 #define _PATH_ "./file.tmp"
  9 #define _SIZE_ 100
 10 
 11 int main()
 12 {
 13     int fd=open(_PATH_,O_RDONLY);
 14     if(fd<0)
 15     {
 16         printf("open file error!\n");
 17         return 1;
 18     }
 19     char buf[_SIZE_];
 20     memset(buf,‘\0‘,sizeof(buf));
 21     while(1)
 22     {
 23         int ret=read(fd,buf,sizeof(buf));
 24         if(ret<=0)
 25         {
 26             printf("raed end or error!\n");
 27             break;
 28         }
 29         printf("%s\n",buf);
 30         if(strncmp(buf,"quit",4)==0)
 31         {
 32             break;
 33         }
 34     }
 35     close(fd);
 36     return 0;
 37 }

运行结果如下：