linux应用开发基础知识（七）——管道和消息队列进程通信

管道通信

匿名管道

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

pfd[0]用于读管道，而pdf[1]用于写管道。
注意：匿名管道只能用于亲缘关系的进程之间通信。管道通道是单向的，一边读，另一边写。管道可以用于大于两个进程共享。
例如设计父进程读，两个子进程写的代码如下：

#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
int main(int argc, char* argv)
{int pipegd[2];int i;char buf[19]={0};pid_t pid;pid_t pid1;int pi = pipe(pipegd);if(pi<0)
{perror("pipe:");return -1;
}
pid=fork();
if(pid<0){perror("pid create:");return 0;}
else if(pid == 0){close(pipegd[0]);memset(buf, 0, 19);strcpy(buf, "this is b");write(pipegd[1], buf, strlen(buf));}else if(pid>0){pid1=fork();if(pid1<0){perror("pid create:");return 0;}else if(pid1 == 0){close(pipegd[0]);memset(buf, 0, 19);strcpy(buf, "this is a");write(pipegd[1], buf, strlen(buf));}else if(pid1>0){sleep(1);close(pipegd[1]);memset(buf,0,19);read(pipegd[0],buf,19);printf("pipe read is \"%s\"\n",buf);}}
return 0;
}

有名管道

有名管道也叫命名管道。
1、管道文件仅仅是文件系统中的标示，并不在磁盘上占据空间。在使用时，在内存上开辟空间，作为两个进程数据交互的通道。也就是提供一个路径名与之关联，这样，即使与创建有名管道的进程不存在亲缘关系的进程，只要可以访问该路径，就能够通过这个有名管道进行相互通信。
2、并且顾名思义，管道秉承着“先进先出”的原则。先写进去的数据，会被先读出来。
3、并且管道需要读进程先存在，否则写进程是没有什么意义的。
有名管道通信的API

#include  <unistd.h>
#include <fcntl.h>
//创建管道的头文件
#include <sys/types.h>
#include <sys/stat.h>
int  mkfifo(const char *path, mode_t mode);
open(const char *path, O_RDONLY);//1
open(const char *path, O_RDONLY | O_NONBLOCK);//无阻塞读
open(const char *path, O_WRONLY);//3
open(const char *path, O_WRONLY | O_NONBLOCK);//无阻塞写

并且需要注意
1）使用open函数打开管道文件
如果一个进程以只读(只写)打开，那么这个进程会被阻塞到open，直到另一个进程以只写(只读)或者读写。
2）使用read函数读取内容
read读取普通文件，read不会阻塞。而read读取管道文件，read会阻塞运行，直到管道中有数据或者所有的写端关闭。
利用上面的API实现父子进程通信：子进程写，父进程读

#include"stdio.h"
#include"unistd.h"
#include"string.h"
#include"fcntl.h"
#include <sys/types.h>
#include <sys/stat.h>
int main(int argc,char* argv[])
{int pd,fd1,fd2;char buf[20]={0};char buf1[20]="hello,world!";char str[]="./my";pid_t pid;pd = mkfifo(str,S_IFIFO|0666);if(pd<0){perror("mkfifo:");return -1;}pid = fork();if(pid<0){perror("pthread creat");}if(pid==0){fd2 = open(str,O_WRONLY);if(fd2<0){perror("write:");return -1;}write(fd2,buf1,20);}else{fd1 = open(str,O_RDONLY); if(fd1<0){perror("read:");return -1;}read(fd1,buf,20);printf("read = %s\n",buf);}
return 0;
}

创建两个进程来实现非亲缘关系进程通信
read部分

#include"stdio.h"
#include"string.h"
#include"unistd.h"
#include"sys/types.h"
#include"sys/stat.h"
#include <fcntl.h>
int main(int argc,char* argv[])
{int pd,fd;pid_t pid;char str[]="./mypipe";char buf[]="you!";// pd = mkfifo(str,0666);// if(pd<0)// {//     perror("mkfifo");//     return -1;// }fd = open(str,O_WRONLY);if(fd<0){perror("open");return -1;}while(1){int ret = write(fd,buf,sizeof(buf));if(ret<0){perror("write");return -1;}printf("write successful!");printf("write buf is %s",buf);sleep(1);}return 0;
}

write部分

#include"stdio.h"
#include"string.h"
#include"unistd.h"
//创建管道头文件
#include"sys/types.h"
#include"sys/stat.h"
//下面的大写宏定义头文件
#include <fcntl.h>
int main(int argc,char* argv[])
{int pd,fd;pid_t pid;char str[]="./mypipe";char buf[30];fd = open(str,O_RDONLY);if(fd<0){perror("open");return -1;}read(fd,buf,30);printf("read is:%s\n",buf);return 0;
}

需要两边都开着才行，不然会进行堵塞。

总结就是:
（1）两个进程运行时，写端彻底关闭，则读端read返回0，也会关闭。
（2）如果管道的读端关闭，继续写入数据会发生异常，写端收到未捕获的信号SIGPIPE会关闭写端。当然也可以修改默认的信号响应方式，比如增加信号处理函数。
（3）写端写入数据以后，读端不从里面读取内容：数据保持在管道中存在一段时间。管道文件的大小是0。
（4）管道通讯发送的数据若没有指定进程接收，任何一个进程只要打开的是同一个管道文件，都有可能读到数据。
（5）read读取管道中的数据，只要读过的数据就会被清空 。

消息队列

消息队列的本质就是存放在内存中的消息的链表，而消息本质上是用户自定义的数据结构。如果进程从消息队列中读取了某个消息，这个消息就会被从消息队列中删除。
对比一下管道机制：

1、消息队列允许一个或多个进程向它写入或读取消息。
2、消息队列可以实现消息的随机查询，不一定非要以先进先出的次序读取消息，也可以按消息的类型读取。比有名管道的先进先出原则更有优势。
3、对于消息队列来说，在某个进程往一个队列写入消息之前，并不需要另一个进程在该消息队列上等待消息的到达。而对于管道来说，除非读进程已存在，否则先有写进程进行写入操作是没有意义的。
4、消息队列的生命周期随内核，如果没有释放消息队列或者没有关闭操作系统，消息队列就会一直存在。而匿名管道随进程的创建而建立，随进程的结束而销毁。

需要注意的是，消息队列对于交换较少数量的数据很有用，因为无需避免冲突。但是，由于用户进程写入数据到内存中的消息队列时，会发生从用户态拷贝数据到内核态的过程；同样的，另一个用户进程读取内存中的消息数据时，会发生从内核态拷贝数据到用户态的过程。因此，如果数据量较大，使用消息队列就会造成频繁的系统调用，也就是需要消耗更多的时间以便内核介入。

消息队列的一些API

 #include <sys/ipc.h>#include <sys/msg.h>key_t ftok(const char *pathname, int proj_id);把一个已存在的路径名和一个整数标识符转换成IPC键值int msgget(key_t key, int msgflg);创建一个消息队列的函数int msgsnd(int msgid, const void *msgp, size_t size, int msgflg);向这个消息队列发送消息int msgrcv(int msgid, void *msgp, size_t size, long msgtype, int msgflg);向这个消息队列读取消息int msgctl(int msgid, int cmd, struct msqid_ds *buf);消息队列的控制

对这些API的解释：

key_t ftok(const char *pathname, int proj_id);
把一个已存在的路径名和一个整数标识符转换成IPC键值

1、成功时返回返回key_t值（即IPC 键值），失败时返回-1；
2、pathname：指定的文件，此文件必须存在且可存取； proj_id：计划代号（project ID）。
3、在使用ftok()函数时，里面有两个参数，即fname和id，fname为指定的文件名，而id为子序列号，这个函数的返回值就是key，它与指定的文件的索引节点号和子序列号id有关，但是如果文件被删除然后重新创建了一个一样的，这个key值也会变的。

 int msgget(key_t key, int msgflg);创建一个消息队列的函数

1、成功时返回消息队列的id，失败时返回EOF(-1)
2、key和消息队列关联的key IPC_PRIVATE 或 ftok
3、msgflg 标志位: IPC_CREAT|0666，IPC_CREAT：没有创建则创建，有则打开。

int msgsnd(int msgid, const void *msgp, size_t size, int msgflg);
向这个消息队列发送消息

1、成功时返回0，失败时返回-1
2、msgid：消息队列id；msgp：消息缓冲区地址；size：消息正文长度
3、msgflg：标志位 0 或 IPC_NOWAIT
0：当消息队列满时，msgsnd将会阻塞，直到消息能写进消息队列
IPC_NOWAIT： 当消息队列已满的时候，msgsnd函数不等待立即返回

int msgrcv(int msgid, void *msgp, size_t size, long msgtype, int msgflg);
向这个消息队列读取消息

1、成功时返回收到的消息长度，失败时返回-1
2、msgid : 消息队列id；msgp : 消息缓冲区地址；size : 指定接收的消息长度；msgtype : 指定接收的消息类型；
msgtype=0： 收到的第一条消息，任意类型。
msgtype>0： 收到的第一条 msg_type类型的消息。
msgtype<0： 接收类型等于或者小于msgtype绝对值的第一个消息。
例子：如果msgtype=-4，只接受类型是1、2、3、4的消息
3、msgflg : 标志位
0：阻塞式接收消息
IPC_NOWAIT： 如果没有返回条件的消息调用立即返回，此时错误码为ENOMSG
MSG_EXCEPT： 与msgtype配合使用返回队列中第一个类型不为msgtype的消息

 int msgctl(int msgid, int cmd, struct msqid_ds *buf);消息队列的控制

1、成功时返回0，失败时返回-1
2、msgid : 消息队列id；cmd : 要执行的操作 IPC_STAT/ IPC_SET / IPC_RMID（删除）
3、buf : 存放消息队列属性的地址

创建两个.c文件来实现消息队列的写入和读取。

写入消息队列

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#define LEN (sizeof(MSG) - sizeof(long))
typedef struct
{long mtype;char mtext[64];
}MSG;
int main(int argc,char *argv[])
{MSG buf;key_t key;int msgid,mssend,msrecv;//fgets(buf.mtext,64,stdin);if((key = ftok(".",'q')) == -1){perror("ftok");return -1;}if(msgid = msgget(key,IPC_CREAT|0666)<0){perror("magid");return -1;}buf.mtype = 1;strcpy(buf.mtext, "this is message 1");if(mssend = msgsnd(msgid,buf.mtext,LEN,0)<0){perror("mssend");return -1;}buf.mtype = 2;strcpy(buf.mtext, "this is message 2");if(mssend = msgsnd(msgid,buf.mtext,LEN,0)<0){perror("mssend");return -1;}buf.mtype = 3;strcpy(buf.mtext, "this is message 3");if(mssend = msgsnd(msgid,buf.mtext,LEN,0)<0){perror("mssend");return -1;}return 0;
}

读取消息队列

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#define LEN (sizeof(MSG) - sizeof(long))
typedef struct
{long mtype;char mtext[64];
}MSG;
int main(int argc,char *argv[])
{MSG buf;key_t key;int msgid,msrecv;buf.mtype = 1;int count = 0;//fgets(buf.mtext,64,stdin);if((key = ftok(".",'q')) == -1){perror("ftok");return -1;}if(msgid = msgget(key,IPC_CREAT|0666)<0){perror("magid");return -1;}while(1){if(msrecv = msgrcv(msgid,&buf,64,0,0) < 0){perror("msrecv");return -1;}printf("msrecv = %s\n",buf.mtext);count++;if(count==3)break;}return 0;
}