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 }
运行结果如下：
