程序博客网 > 淘宝cd

Linux POSIX 消息队列

来源：互联网 发布：淘宝cd 编辑：程序博客网 时间：2024/06/05 11:35

【版权声明：尊重原创，转载请保留出处：blog.csdn.net/shallnet 或 .../gentleliu，文章仅供学习交流，请勿用于商业用途】

消息队列可以看作一系列消息组织成的链表，一个程序可以往这个链表添加消息，另外的程序可以从这个消息链表读走消息。

  • mq_open()函数打开或创建一个posix消息队列。
[cpp] view plain copy 
  1. #include <fcntl.h>           /* For O_* constants */  
  2. #include <sys/stat.h>        /* For mode constants */  
  3. #include <mqueue.h>  
  4. mqd_t mq_open(const char *name, int oflag);  
  5. mqd_t mq_open(const char *name, int oflag, mode_t mode,  
  6.               struct mq_attr *attr);  
  7. Link with -lrt.  
参数name为posix IPC名字， 即将要被打开或创建的消息队列对象，为了便于移植，需要指定为“/name”的格式。
参数oflag必须要有O_RDONLY（只读）、标志O_RDWR(读写)， O_WRONLY（只写）之一，除此之外还可以指定O_CREAT（没有该对象则创建）、O_EXCL（如果O_CREAT指定，但name不存在，就返回错误），O_NONBLOCK（以非阻塞方式打开消息队列，在正常情况下mq_receive和mq_send函数会阻塞的地方，使用该标志打开的消息队列会返回EAGAIN错误）。
当操作一个新队列时，使用O_CREAT标识，此时后面两个参数需要被指定，参数mode为指定权限位，attr指定新创建队列的属性。

  • mq_close()函数关闭消息队列。
[cpp] view plain copy 
  1. #include <mqueue.h>  
  2. int mq_close(mqd_t mqdes);  
  3. Link with -lrt.  
关闭之后调用进程不在使用该描述符，但消息队列不会从系统中删除，进程终止时，会自动关闭已打开的消息队列，和调用mq_close一样。参数为mq_open()函数返回的值。

  • mq_unlink()函数从系统中删除某个消息队列。
    [cpp] view plain copy
    1. #include <mqueue.h>  
    2. int mq_unlink(const char *name);  
    3. Link with -lrt.  

删除会马上发生，即使该队列的描述符引用计数仍然大于0。参数为mq_open()函数第一个参数。

  • mq_setattr()函数和mq_getattr()函数分别设置和和获取消息队列属性。
[cpp] view plain copy 
  1. #include <mqueue.h>  
  2. int mq_getattr(mqd_t mqdes, struct mq_attr *attr);  
  3. int mq_setattr(mqd_t mqdes, struct mq_attr *newattr,  struct mq_attr *oldattr);   
  4. Link with -lrt.  
参数mqdes为mq_open()函数返回的消息队列描述符。
参数attr、newattr、oldattr为消息队列属性结构体指针；
[cpp] view plain copy 
  1. struct mq_attr {  
  2.     long mq_flags;       /* Flags: 0 or O_NONBLOCK */  
  3.     long mq_maxmsg;      /* Max. # of messages on queue */  
  4.     long mq_msgsize;     /* Max. message size (bytes) */  
  5.     long mq_curmsgs;     /* # of messages currently in queue */  
  6. };  
参数mq_flags在mq_open时被初始化（oflag参数），其值为0 或者 O_NONBLOCK。
参数mq_maxmsg和mq_msgsize在mq_open时在参数attr中初始化设置，mq_maxmsg是指队列的消息个数最大值；mq_msgsize为队列每个消息的最大值。
参数mq_curmsgs为当前队列消息。

mq_getattr()函数把队列当前属性填入attr所指向的结构体。
mq_setattr()函数只能设置mq_flags属性，另外的域会被自动忽略，mq_maxmsg和mq_msgsize的设置需要在mq_open当中来完成， 参数oldattr会和函数mq_getattr函数中参数attr相同的值。

  • mq_send() 函数 和mq_receive()函数分别用于向消息队列放置和取走消息。
[cpp] view plain copy 
  1. #include <mqueue.h>  
  2. int mq_send(mqd_t mqdes, const char *msg_ptr,   size_t msg_len, unsigned msg_prio);   
  3. ssize_t mq_receive(mqd_t mqdes, char *msg_ptr,  size_t msg_len, unsigned *msg_prio);   
  4. Link with -lrt.  
参数msg_ptr为指向消息的指针。
msg_len为消息长度，该值不能大于属性值中mq_msgsize的值。
msg_prio为优先级，消息在队列中将按照优先级大小顺序来排列消息。
如果消息队列已满，mq_send()函数将阻塞，直到队列有可用空间再次允许放置消息或该调用被信号打断；如果O_NONBLOCK被指定，mq_send()那么将不会阻塞，而是返回EAGAIN错误。如果队列空，mq_receive()函数将阻塞，直到消息队列中有新的消息；如果O_NONBLOCK被指定，mq_receive()那么将不会阻塞，而是返回EAGAIN错误。


示例：

服务进程：
[cpp] view plain copy 
  1. int sln_ipc_mq_loop(void)  
  2. {  
  3.     mqd_t           mqd;  
  4.     struct mq_attr  setattr, attr;  
  5.     char            *recvbuf = NULL;  
  6.     unsigned int    prio;  
  7.     int             recvlen;  
  8.   
  9.     setattr.mq_maxmsg = SLN_IPC_MQ_MAXMSG;  
  10.     setattr.mq_msgsize = SLN_IPC_MQ_MSGSIZE;  
  11.   
  12.     mqd = mq_open(SLN_IPC_MQ_NAME, O_RDWR | O_CREAT | O_EXCL, 0644, &setattr); //创建消息队列并设置消息队列属性  
  13.     if ((mqd < 0) && (errno != EEXIST)) {  
  14.         fprintf(stderr, "mq_open: %s\n", strerror(errno));  
  15.         return -1;  
  16.     }  
  17.   
  18.     if ((mqd < 0) && (errno == EEXIST)) { // 消息队列存在则打开  
  19.         mqd = mq_open(SLN_IPC_MQ_NAME, O_RDWR);  
  20.         if (mqd < 0) {  
  21.             fprintf(stderr, "mq_open: %s\n", strerror(errno));  
  22.             return -1;  
  23.         }  
  24.     }  
  25.   
  26.     if (mq_getattr(mqd, &attr) < 0) { //获取消息队列属性  
  27.         fprintf(stderr, "mq_getattr: %s\n", strerror(errno));  
  28.         return -1;  
  29.     }  
  30.   
  31.     printf("flags: %ld, maxmsg: %ld, msgsize: %ld, curmsgs: %ld\n",  
  32.             attr.mq_flags, attr.mq_maxmsg, attr.mq_msgsize, attr.mq_curmsgs);  
  33.   
  34.     recvbuf = malloc(attr.mq_msgsize); //为读取消息队列分配当前系统允许的每条消息的最大大小的内存空间  
  35.     if (NULL == recvbuf) {  
  36.         return -1;  
  37.     }  
  38.   
  39.     for (;;) {  
  40.         recvlen = mq_receive(mqd, recvbuf, attr.mq_msgsize, &prio); //从消息队列中读取消息  
  41.         if (recvlen < 0) {  
  42.             fprintf(stderr, "mq_receive: %s\n", strerror(errno));  
  43.             continue;  
  44.         }  
  45.   
  46.         printf("recvive length: %d, prio: %d, recvbuf: %s\n", recvlen, prio, recvbuf);  
  47.     }  
  48.   
  49.     return 0;  
  50. }  
客户进程：
[cpp] view plain copy 
  1. int sln_ipc_mq_send(const char *sendbuf, int sendlen, int prio)  
  2. {  
  3.     mqd_t           mqd;  
  4.   
  5.     mqd = mq_open(SLN_IPC_MQ_NAME, O_WRONLY); //客户进程打开消息队列  
  6.     if (mqd < 0) {  
  7.         fprintf(stderr, "mq_open: %s\n", strerror(errno));  
  8.         return -1;  
  9.     }  
  10.   
  11.     if (mq_send(mqd, sendbuf, sendlen, prio) < 0) { //客户进程网消息队列中添加一条消息  
  12.         fprintf(stderr, "mq_send: %s\n", strerror(errno));  
  13.         return -1;  
  14.     }  
  15.   
  16.     return 0;  
  17. }  
        程序运行时，服务进程阻塞于mq_receive，客户进程每发一条消息队列，服务进程都会从mq_receive处返回，但不一定接收到的消息就是客户进程最近发送的那一条消息，因为客户进程往消息队列中添加消息时会按照优先级来排序，如果客户进程同时向消息队列添加多条消息，服务进程还未来得及读取，那么当服务进程开始读取的消息一定是优先级最高的那条消息，而不是客户进程最先发送的那一条消息。
我们将服务进程稍作修改来试一下：
[cpp] view plain copy 
  1. int sln_ipc_mq_loop(void)  
  2. {  
  3.     mqd_t           mqd;  
  4.     struct mq_attr  setattr, attr;  
  5.     char            *recvbuf = NULL;  
  6.     unsigned int    prio;  
  7.     int             recvlen;  
  8.     memset(&setattr, 0, sizeof(setattr));  
  9.     setattr.mq_maxmsg = SLN_IPC_MQ_MAXMSG;  
  10.     setattr.mq_msgsize = SLN_IPC_MQ_MSGSIZE;  
  11.     mqd = mq_open(SLN_IPC_MQ_NAME, O_RDWR | O_CREAT | O_EXCL, 0644, &setattr);  
  12.     //mqd = mq_open(SLN_IPC_MQ_NAME, O_RDWR | O_CREAT | O_EXCL, 0644, NULL);  
  13.     if ((mqd < 0) && (errno != EEXIST)) {  
  14.         fprintf(stderr, "mq_open: %s\n", strerror(errno));  
  15.         return -1;  
  16.     }  
  17.     if ((mqd < 0) && (errno == EEXIST)) { // name is exist  
  18.         mqd = mq_open(SLN_IPC_MQ_NAME, O_RDWR);  
  19.         if (mqd < 0) {  
  20.             fprintf(stderr, "mq_open: %s\n", strerror(errno));  
  21.             return -1;  
  22.         }  
  23.     }  
  24.     if (mq_getattr(mqd, &attr) < 0) {  
  25.         fprintf(stderr, "mq_getattr: %s\n", strerror(errno));  
  26.         return -1;  
  27.     }  
  28.     printf("flags: %ld, maxmsg: %ld, msgsize: %ld, curmsgs: %ld\n",  
  29.             attr.mq_flags, attr.mq_maxmsg, attr.mq_msgsize, attr.mq_curmsgs);  
  30.     recvbuf = malloc(attr.mq_msgsize);  
  31.     if (NULL == recvbuf) {  
  32.         return -1;  
  33.     }  
  34.     sleep(10); //此处等待10秒，此时客户进程一次性向消息队列加入多条消息  
  35.     for (;;) {  
  36.         if (mq_getattr(mqd, &attr) < 0) {  
  37.             fprintf(stderr, "mq_getattr: %s\n", strerror(errno));  
  38.             return -1;  
  39.         }  
  40.         printf("msgsize: %ld, curmsgs: %ld\n", attr.mq_msgsize, attr.mq_curmsgs);  
  41.         recvlen = mq_receive(mqd, recvbuf, attr.mq_msgsize, &prio);  
  42.         if (recvlen < 0) {  
  43.             fprintf(stderr, "mq_receive: %s\n", strerror(errno));  
  44.             continue;  
  45.         }  
  46.         printf("recvive-> prio: %d, recvbuf: %s\n", prio, recvbuf);  
  47.         sleep(1); //每秒处理一个消息  
  48.     }  
  49.     mq_close(mqd);  
  50.     return 0;  
  51. }  
服务进程先运行，然后客户进程立即向消息队列加入12消息，每条消息优先级从1到12，，之后服务进程运行，程序运行如下：
[cpp] view plain copy 
  1. # ./server  
  2. flags: 0, maxmsg: 10, msgsize: 1024, curmsgs: 0  
  3. msgsize: 1024, curmsgs: 10  
  4. recvive-> prio: 10, recvbuf: asdf  
  5. msgsize: 1024, curmsgs: 10  
  6. recvive-> prio: 11, recvbuf: 1234  
  7. msgsize: 1024, curmsgs: 10  
  8. recvive-> prio: 12, recvbuf: asdf  
  9. msgsize: 1024, curmsgs: 9  
  10. recvive-> prio: 9, recvbuf: 1234  
  11. msgsize: 1024, curmsgs: 8  
  12. recvive-> prio: 8, recvbuf: asdf  
  13. msgsize: 1024, curmsgs: 7  
  14. recvive-> prio: 7, recvbuf: 1234  
  15. msgsize: 1024, curmsgs: 6  
  16. recvive-> prio: 6, recvbuf: asdf  
  17. msgsize: 1024, curmsgs: 5  
  18. recvive-> prio: 5, recvbuf: 1234  
  19. msgsize: 1024, curmsgs: 4  
  20. recvive-> prio: 4, recvbuf: asdf  
  21. msgsize: 1024, curmsgs: 3  
  22. recvive-> prio: 3, recvbuf: 1234  
  23. msgsize: 1024, curmsgs: 2  
  24. recvive-> prio: 2, recvbuf: asdf  
  25. msgsize: 1024, curmsgs: 1  
  26. recvive-> prio: 1, recvbuf: 1234  
  27. msgsize: 1024, curmsgs: 0  
        可以看到，系统允许最大消息数量是10条，当客户进程一次性加入12条消息时，客户进程在加入最后两条会阻塞在那里，直到服务进程取出消息之后，最后两天消息才能依次加入到消息队列。并且服务进程取出消息时从优先级从高到低取出：10->11->12->9->8->... ->1

阅读全文
0 0
淘宝cd 淘宝cd
原创粉丝点击
热门IT博客
recuva数据恢复recuva数据恢复
只有域名怎么绑定微博只有域名怎么绑定微博
mac系统玩不了魔兽
软件开发的心得体会
java返回值类型有哪些
工信部手机预装软件
centos pptp 客户端
新网域名登录
程序员适合在哪写博客
宏晶stc单片机
mac玩英雄杀
淘宝客推广如何设置
阿里云et是哪个缩写
移民行业数据分析
小学英语课文朗读软件
奇葩室友 知乎
手机网络电视直播
amt emulator mac
c语言编程实例100题
淘宝内衣店名字大全
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 星露谷物语松露油 油角皮怎么做才松脆 油松多少钱 松油怎么洗 油松树苗价格 松哥油焖大虾 今年松油多少钱一斤 油松树苗批发 松油价格 松油的作用 割松油一斤多少钱 割松油 松油收购价格 松油素 甲酸松油酯 薄荷油 水杨酸苯甲酸松油搽剂 松浦 松浦豪 松浦雅 松浦镜鲤 松浦大桥 松浦敬之 松浦弥太郎 松浦爱弓 松浦淳六郎 松浦胜人事件 松浦净水器好不好 松涛 松涛松涛我的亲人 松溉古镇 松溉古镇旅游 溉组词 溉 溉怎么读 溉字组词 淤溉 溉的组词 溉的拼音 溉怎么组词 溉可以组什么词

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里