Posix消息队列

简介:

 消息队列可以认为是一个消息链表,某个进程往一个消息队列中写入消息之前,不需要另外某个进程在该队列上等待消息的达到,这一点与管道和FIFO相反。Posix消息队列与System V消息队列的区别如下:
1. 对Posix消息队列的读总是返回最高优先级的最早消息,对System V消息队列的读则可以返回任意指定优先级的消息。
2. 当往一个空队列放置一个消息时,Posix消息队列允许产生一个信号或启动一个线程,System V消息队列则不提供类似的机制。

Posix消息队列操作函数如下:

#include    <mqueue.h>
typedef int mqd_t;
mqd_t mq_open(const char *name, int oflag, ... /* mode_t mode, struct mq_attr *attr */);
返回: 成功时为消息队列描述字,出错时为-1。   
功能: 创建一个新的消息队列或打开一个已存在的消息的队列。     

#include    <mqueue.h>
int mq_close(mqd_t mqdes);
返回: 成功时为0,出错时为-1。
功能: 关闭已打开的消息队列。

#include    <mqueue.h>
int mq_unlink(const char *name)
返回: 成功时为0,出错时为-1
功能: 从系统中删除消息队列。

#include    <mqueue.h>
int mq_getattr(mqd_t mqdes, struct mq_attr *attr);
int mq_setattr(mqd_t mqdes, const struct mq_attr *attr, struct mq_attr *attr);
均返回:成功时为0, 出错时为-1

每个消息队列有四个属性:
struct mq_attr
{
    long mq_flags;      /* message queue flag : 0, O_NONBLOCK */
    long mq_maxmsg;     /* max number of messages allowed on queue*/
    long mq_msgsize;    /* max size of a message (in bytes)*/
    long mq_curmsgs;    /* number of messages currently on queue */
};

每个消息均有一个优先级,它是一个小于MQ_PRIO_MAX的无符号整数
#define MQ_PRIO_MAX 32768

#include    <mqueue.h>
int mq_send(mqd_t mqdes, const char *ptr, size_t len, unsigned int prio);
返回:成功时为0,出错为-1
ssize_t mq_receive(mqd_t mqdes, char *ptr, size_t len, unsigned int *priop);
返回:成功时为消息中的字节数,出错为-1

消息队列的限制:
MQ_OPEN_MAX : 一个进程能够同时拥有的打开着消息队列的最大数目
MQ_PRIO_MAX : 任意消息的最大优先级值加1

#include    <mqueue.h>
int mq_notify(mqd_t mqdes, const struct sigevent *notification);
返回: 成功时为0,出错时为-1
功能: 给指定队列建立或删除异步事件通知

union sigval
{
    int sival_int;      /* Integer value */
    void *sival_ptr;    /* pointer value */
};

struct sigevent
{
    int     sigev_notify;   /* SIGEV_{ NONE, ISGNAL, THREAD} */
    int     sigev_signo;    /* signal number if SIGEV_SIGNAL */
    union sigval sigev_value;   /* passed to signal handler or thread */
    void    (*sigev_notify_function)(union sigval);
    pthread_attr_t *sigev_notify_attribute;
}; 

异步信号安全函数
#include    <signal.h>
int sigwait(const sigset_t *set, int *sig);

Posxi实时信号
信号可划分为两大小组:
1. 其值在SIGRTMIN和SIGRTMAX之间(包括两者在内)的实时信号。
2. 所有其他信号:SIGALRM, SIGINT, SIGKILL等等。

void func(int signo, siginfo_t *info, void *context);

typedef struct
{
    int     si_signo;   /* same value as signo argument */
    int     si_code;    /* SI_{USER, QUEUE, TIMER, ASYNCIO, MESGQ}*/
    union sigval si_value;    /* integer or pointer value from sender */
} siginfo_t;

下面采用上面的函数,写程序进程测试。

程序1:创建一个消息队列,其名字是作为命令行参数指定,消息队列创建成功后输出队列的属性。程序如下:

View Code
复制代码
 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <unistd.h>
 4 #include <mqueue.h>
 5 #include <fcntl.h>
 6 #include <errno.h>
 7 #include<sys/stat.h>
 8 #define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
 9 
10 int main(int argc,char *argv[])
11 {
12     int     c,flags;
13     mqd_t   mqd;
14     struct mq_attr  attr;
15 
16     flags = O_RDWR|O_CREAT;
17     printf("create mqueue.\n");
18     while((c = getopt(argc,argv,"e")) != -1)
19     {
20         switch(c)
21         {
22             case 'e':
23                 flags |= O_EXCL;
24                 break;
25         }
26     }
27     if(optind != argc-1)
28     {
29         perror("usage: mqcreate [-e] <name>");
30         exit(0);
31     }
32     if((mqd = mq_open(argv[optind],flags,FILE_MODE,NULL)) == -1)
33     {
34         perror("mq_open() error");
35         exit(-1);
36     }
37     mq_getattr(mqd,&attr);
38     printf("max #msgs = %ld,max #bytes/msg = %ld,#currently on queue = %ld\n",
39            attr.mq_maxmsg,attr.mq_msgsize,attr.mq_curmsgs);
40     mq_close(mqd);
41     exit(0);
42 }
复制代码

本测试是用的Linux Ubuntu系统,编译程序的时候需要添加-lrt连接,如果不加会提示如下错误信息

因此正确编译的方式如下:

程序编译完成后,如果直接运行程序则提示mq_open失败,提示mq_open permission denied。解决办法是:

mkdir /dev/mqueue
mount -t mqueue none /dev/mqueue

然后再运行即可看到创建的消息队列。程序结果如下所示:

 程序2:练习mq_send和mq_receive函数,调用mqsend程序向消息队列中写入消息,调用mqreceive程序从消息队列中读取消息。程序如下所示:

mqsend程序:

View Code
复制代码
 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <unistd.h>
 4 #include <mqueue.h>
 5 #include <fcntl.h>
 6 #include <errno.h>
 7 #include<sys/stat.h>
 8 typedef unsigned int  uint_t;
 9 
10 int main(int argc,char *argv[])
11 {
12     mqd_t   mqd;
13     void    *ptr;
14     size_t  len;
15     uint_t  prio;
16     if(argc != 4)
17     {
18         printf("usage: mqsend <name> <$bytes> <priority>\n");
19         exit(0);
20     }
21     len = atoi(argv[2]);
22     prio = atoi(argv[3]);
23     mqd = mq_open(argv[1],O_WRONLY);
24     ptr = calloc(len,sizeof(char));
25     if(mq_send(mqd,ptr,len,prio) == -1)
26     {
27         perror("mq_send() error:");
28         exit(-1);
29     }
30     exit(0);
31 }
复制代码

mqreceive程序:

View Code
复制代码
 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <unistd.h>
 4 #include <mqueue.h>
 5 #include <fcntl.h>
 6 #include <errno.h>
 7 #include<sys/stat.h>
 8 typedef unsigned int  uint_t;
 9 
10 int main(int argc,char *argv[])
11 {
12     int     c,flags;
13     mqd_t   mqd;
14     ssize_t n;
15     uint_t  prio;
16     void *buff;
17     struct mq_attr attr;
18 
19     flags = O_RDONLY;
20     while((c = getopt(argc,argv,"n")) != -1)
21     {
22         switch(c)
23         {
24             case 'n':
25                 flags |= O_NONBLOCK;  //设置为非阻塞
26                 break;
27         }
28     }
29     if(optind != argc-1)
30     {
31         printf("usage: mqreceive [-n] <name>");
32         exit(0);
33     }
34     mqd = mq_open(argv[optind],flags);
35     mq_getattr(mqd,&attr);
36     buff = malloc(attr.mq_msgsize);
37     if((n = mq_receive(mqd,buff,attr.mq_msgsize,&prio)) == -1)
38     {
39         perror("mq_receive error: ");
40         exit(-1);
41     }
42     printf("read %ld bytes,priority = %u\n",(long) n,prio);
43     exit(0);
44 }
复制代码

程序执行结果如下所示:

程序3:信号通知函数使用,当有一个消息放置到某个空队列中,该程序产生信号,通知进程消息队列中放入了一个新的消息。程序如下:

复制代码
 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <unistd.h>
 4 #include <mqueue.h>
 5 #include <fcntl.h>
 6 #include <errno.h>
 7 #include <signal.h>
 8 
 9 typedef unsigned int  uint_t;
10 
11 volatile    sig_atomic_t mqflag;  //全局变量,检查信号的产生
12 static void sig_usr1(int);
13 
14 int main(int argc,char *argv[])
15 {
16     mqd_t       mqd;
17     void        *buff;
18     ssize_t     n;
19     sigset_t    zeromask,newmask,oldmask;
20     struct mq_attr  attr;
21     struct sigevent sigev;
22     if(argc != 2)
23     {
24         printf("usage :mqnotify <name>");
25         exit(0);
26     }
27     mqd = mq_open(argv[1],O_RDONLY);
28     mq_getattr(mqd,&attr);
29     buff = malloc(attr.mq_msgsize);
30     sigemptyset(&zeromask);
31     sigemptyset(&newmask);
32     sigemptyset(&oldmask);
33     sigaddset(&newmask,SIGUSR1);
34     signal(SIGUSR1,sig_usr1);
35     sigev.sigev_notify = SIGEV_SIGNAL;
36     sigev.sigev_signo = SIGUSR1;
37     if(mq_notify(mqd,&sigev) == -1)
38     {
39         perror("mq_notify error");
40         exit(-1);
41     }
42     for(; ;)
43     {
44         sigprocmask(SIG_BLOCK,&newmask,&oldmask);
45         while(mqflag == 0)
46             sigsuspend(&zeromask); //挂起,等待
47         mqflag = 0;
48         mq_notify(mqd,&sigev);
49         n = mq_receive(mqd,buff,attr.mq_msgsize,NULL);
50         printf("read %ld bytes\n",(long) n);
51         sigprocmask(SIG_UNBLOCK,&newmask,NULL);
52     }
53     eixt(0);
54 }
55 
56 static void sig_usr1(int signo)
57 {
58     mqflag = 1;
59     return ;
60 }
复制代码

程序执行结果如下:

可以使用sigwait函数代替信号处理程序的信号通知,将信号阻塞到某个函数中,仅仅等待该信号的递交。采用sigwait实现上面的程序如下:

复制代码
 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <unistd.h>
 4 #include <mqueue.h>
 5 #include <fcntl.h>
 6 #include <errno.h>
 7 #include <signal.h>
 8 
 9 int main(int argc,char *argv[])
10 {
11     mqd_t       mqd;
12     int         signo;
13     void        *buff;
14     ssize_t     n;
15     sigset_t    newmask;
16     struct mq_attr  attr;
17     struct sigevent sigev;
18     if(argc != 2)
19     {
20         printf("usage :mqnotify <name>");
21         exit(0);
22     }
23     mqd = mq_open(argv[1],O_RDONLY);
24     mq_getattr(mqd,&attr);
25     buff = malloc(attr.mq_msgsize);
26     sigemptyset(&newmask);
27     sigaddset(&newmask,SIGUSR1);
28     sigprocmask(SIG_BLOCK,&newmask,NULL);
29     
30     sigev.sigev_notify = SIGEV_SIGNAL;
31     sigev.sigev_signo = SIGUSR1;
32     if(mq_notify(mqd,&sigev) == -1)
33     {
34         perror("mq_notify error");
35         exit(-1);
36     }
37     for(; ;)
38     {
39        sigwait(&newmask,&signo); //阻塞并等待该信号
40        if(signo == SIGUSR1)
41        {
42             mq_notify(mqd,&sigev);
43             while((n = mq_receive(mqd,buff,attr.mq_msgsize,NULL))>=0)
44                 printf("read %ld bytes\n",(long) n);
45             if(errno != EAGAIN)
46             {
47                 perror("mq_receive error");
48                 exit(-1);
49             }
50        }
51     }
52     eixt(0);
53 }
复制代码

 启动线程处理消息通知,程序如下:

复制代码
 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <unistd.h>
 4 #include <mqueue.h>
 5 #include <fcntl.h>
 6 #include <errno.h>
 7 #include <signal.h>
 8 
 9 mqd_t       mqd;
10 struct mq_attr  attr;
11 struct sigevent sigev;
12 static void notify_thread(union sigval);
13 
14 int main(int argc,char *argv[])
15 {
16 
17     if(argc != 2)
18     {
19         printf("usage :mqnotify <name>");
20         exit(0);
21     }
22     mqd = mq_open(argv[1],O_RDONLY | O_NONBLOCK);
23     mq_getattr(mqd,&attr);
24 
25     sigev.sigev_notify = SIGEV_THREAD;
26     sigev.sigev_value.sival_ptr = NULL;
27     sigev.sigev_notify_function = notify_thread;
28     sigev.sigev_notify_attributes = NULL;
29 
30     if(mq_notify(mqd,&sigev) == -1)
31     {
32         perror("mq_notify error");
33         exit(-1);
34     }
35     for(; ;)
36     {
37         pause();
38     }
39     eixt(0);
40 }
41 static void notify_thread(union sigval arg)
42 {
43     ssize_t     n;
44     void        *buff;
45     printf("notify_thread started\n");
46     buff = malloc(attr.mq_msgsize);
47     mq_notify(mqd,&sigev);
48     while((n = mq_receive(mqd,buff,attr.mq_msgsize,NULL))>=0)
49                 printf("read %ld bytes\n",(long) n);
50     if(errno != EAGAIN)
51     {
52                 perror("mq_receive error");
53                 exit(-1);
54     }
55     free(buff);
56     pthread_exit(NULL);
57 }
复制代码

 

相关实践学习
消息队列RocketMQ版:基础消息收发功能体验
本实验场景介绍消息队列RocketMQ版的基础消息收发功能,涵盖实例创建、Topic、Group资源创建以及消息收发体验等基础功能模块。
消息队列 MNS 入门课程
1、消息队列MNS简介 本节课介绍消息队列的MNS的基础概念 2、消息队列MNS特性 本节课介绍消息队列的MNS的主要特性 3、MNS的最佳实践及场景应用 本节课介绍消息队列的MNS的最佳实践及场景应用案例 4、手把手系列:消息队列MNS实操讲 本节课介绍消息队列的MNS的实际操作演示 5、动手实验:基于MNS,0基础轻松构建 Web Client 本节课带您一起基于MNS,0基础轻松构建 Web Client
相关文章
|
7月前
|
消息中间件 Linux API
Linux进程间通信(IPC) Linux消息队列:讲解POSIX消息队列在Linux系统进程间通信中的应用和实践
Linux进程间通信(IPC) Linux消息队列:讲解POSIX消息队列在Linux系统进程间通信中的应用和实践
271 1
Linux进程间通信(IPC) Linux消息队列:讲解POSIX消息队列在Linux系统进程间通信中的应用和实践
|
消息中间件 Linux
Linux IPC实践(7) --Posix消息队列
1. 创建/获取一个消息队列 #include /* For O_* constants */ #include /* For mode constan...
976 0
|
消息中间件 缓存 Linux
消息队列接口API(posix 接口和 system v接口)
消息队列 posix API 消息队列(也叫做报文队列)能够克服早期unix通信机制的一些缺点。信号这种通信方式更像\"即时\"的通信方式,它要求接受信号的进程在某个时间范围内对信号做出反应,因此该信号最多在接受信号进程的生命周期内才有意义,信号所传递的信息是接近于随进程持续的概念(process-persistent);管道及有名管道则是典型的随进程持续IPC,并且,只能传送无格式的字节流无疑会给应用程序开发带来不便,另外,它的缓冲区大小也受到限制消息队列就是一个消息的链表。
1738 0
|
消息中间件 C语言
POSIX和SYSTEM的消息队列应该注意的问题
首先看看POSIX的代码: 1.posix_mq_server.c #include #include #include #include #define MQ_FILE "/mq_test"#define BUF_LEN 128 int main(){     mqd_t mqd;  ...
1073 0
|
消息中间件 Linux 机器学习/深度学习
POSIX 消息队列
POSIX消息队列与System V消息队列的主要区别:1.对POSIX队列的读总数返回最高优先级到最早消息,对SV队列到读则可以返回任意指定优先级的消息2.当往一个空队列放置一个消息时,POSIX允许产生一个信号或启动一个线程,System V不提供此机制消息的属性:1.
941 0
|
5月前
|
消息中间件 C语言 RocketMQ
消息队列 MQ操作报错合集之出现"Connection reset by peer"的错误,该如何处理
消息队列(MQ)是一种用于异步通信和解耦的应用程序间消息传递的服务,广泛应用于分布式系统中。针对不同的MQ产品,如阿里云的RocketMQ、RabbitMQ等,它们在实现上述场景时可能会有不同的特性和优势,比如RocketMQ强调高吞吐量、低延迟和高可用性,适合大规模分布式系统;而RabbitMQ则以其灵活的路由规则和丰富的协议支持受到青睐。下面是一些常见的消息队列MQ产品的使用场景合集,这些场景涵盖了多种行业和业务需求。
|
5月前
|
消息中间件 Java C语言
消息队列 MQ使用问题之在使用C++客户端和GBase的ESQL进行编译时出现core dump,该怎么办
消息队列(MQ)是一种用于异步通信和解耦的应用程序间消息传递的服务,广泛应用于分布式系统中。针对不同的MQ产品,如阿里云的RocketMQ、RabbitMQ等,它们在实现上述场景时可能会有不同的特性和优势,比如RocketMQ强调高吞吐量、低延迟和高可用性,适合大规模分布式系统;而RabbitMQ则以其灵活的路由规则和丰富的协议支持受到青睐。下面是一些常见的消息队列MQ产品的使用场景合集,这些场景涵盖了多种行业和业务需求。
|
1月前
|
消息中间件 存储 Kafka
MQ 消息队列核心原理,12 条最全面总结!
本文总结了消息队列的12个核心原理,涵盖消息顺序性、ACK机制、持久化及高可用性等内容。关注【mikechen的互联网架构】,10年+BAT架构经验倾囊相授。
|
3月前
|
消息中间件
手撸MQ消息队列——循环数组
队列是一种常用的数据结构,类似于栈,但采用先进先出(FIFO)的原则。生活中常见的排队场景就是队列的应用实例。在数据结构中,队列通常用数组实现,包括入队(队尾插入元素)和出队(队头移除元素)两种基本操作。本文介绍了如何用数组实现队列,包括定义数组长度、维护队头和队尾下标(front 和 tail),并通过取模运算解决下标越界问题。此外,还讨论了队列的空与满状态判断,以及并发和等待机制的实现。通过示例代码展示了队列的基本操作及优化方法,确保多线程环境下的正确性和高效性。
51 0
手撸MQ消息队列——循环数组
|
4月前
|
消息中间件 存储 缓存
一个用过消息队列的人,竟不知为何要用 MQ?
一个用过消息队列的人,竟不知为何要用 MQ?
183 1