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：信号通知函数使用，当有一个消息放置到某个空队列中，该程序产生信号，通知进程消息队列中放入了一个新的消息。程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <mqueue.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>

typedef unsigned int  uint_t;

volatile    sig_atomic_t mqflag;  //全局变量，检查信号的产生
static void sig_usr1(int);

int main(int argc,char *argv[])
{
    mqd_t       mqd;
    void        *buff;
    ssize_t     n;
    sigset_t    zeromask,newmask,oldmask;
    struct mq_attr  attr;
    struct sigevent sigev;
    if(argc != 2)
    {
        printf("usage :mqnotify <name>");
        exit(0);
    }
    mqd = mq_open(argv[1],O_RDONLY);
    mq_getattr(mqd,&attr);
    buff = malloc(attr.mq_msgsize);
    sigemptyset(&zeromask);
    sigemptyset(&newmask);
    sigemptyset(&oldmask);
    sigaddset(&newmask,SIGUSR1);
    signal(SIGUSR1,sig_usr1);
    sigev.sigev_notify = SIGEV_SIGNAL;
    sigev.sigev_signo = SIGUSR1;
    if(mq_notify(mqd,&sigev) == -1)
    {
        perror("mq_notify error");
        exit(-1);
    }
    for(; ;)
    {
        sigprocmask(SIG_BLOCK,&newmask,&oldmask);
        while(mqflag == 0)
            sigsuspend(&zeromask); //挂起，等待
        mqflag = 0;
        mq_notify(mqd,&sigev);
        n = mq_receive(mqd,buff,attr.mq_msgsize,NULL);
        printf("read %ld bytes\n",(long) n);
        sigprocmask(SIG_UNBLOCK,&newmask,NULL);
    }
    eixt(0);
}

static void sig_usr1(int signo)
{
    mqflag = 1;
    return ;
}

程序执行结果如下：

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

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <mqueue.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>

int main(int argc,char *argv[])
{
    mqd_t       mqd;
    int         signo;
    void        *buff;
    ssize_t     n;
    sigset_t    newmask;
    struct mq_attr  attr;
    struct sigevent sigev;
    if(argc != 2)
    {
        printf("usage :mqnotify <name>");
        exit(0);
    }
    mqd = mq_open(argv[1],O_RDONLY);
    mq_getattr(mqd,&attr);
    buff = malloc(attr.mq_msgsize);
    sigemptyset(&newmask);
    sigaddset(&newmask,SIGUSR1);
    sigprocmask(SIG_BLOCK,&newmask,NULL);
    
    sigev.sigev_notify = SIGEV_SIGNAL;
    sigev.sigev_signo = SIGUSR1;
    if(mq_notify(mqd,&sigev) == -1)
    {
        perror("mq_notify error");
        exit(-1);
    }
    for(; ;)
    {
       sigwait(&newmask,&signo); //阻塞并等待该信号
       if(signo == SIGUSR1)
       {
            mq_notify(mqd,&sigev);
            while((n = mq_receive(mqd,buff,attr.mq_msgsize,NULL))>=0)
                printf("read %ld bytes\n",(long) n);
            if(errno != EAGAIN)
            {
                perror("mq_receive error");
                exit(-1);
            }
       }
    }
    eixt(0);
}

 启动线程处理消息通知，程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <mqueue.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>

mqd_t       mqd;
struct mq_attr  attr;
struct sigevent sigev;
static void notify_thread(union sigval);

int main(int argc,char *argv[])
{

    if(argc != 2)
    {
        printf("usage :mqnotify <name>");
        exit(0);
    }
    mqd = mq_open(argv[1],O_RDONLY | O_NONBLOCK);
    mq_getattr(mqd,&attr);

    sigev.sigev_notify = SIGEV_THREAD;
    sigev.sigev_value.sival_ptr = NULL;
    sigev.sigev_notify_function = notify_thread;
    sigev.sigev_notify_attributes = NULL;

    if(mq_notify(mqd,&sigev) == -1)
    {
        perror("mq_notify error");
        exit(-1);
    }
    for(; ;)
    {
        pause();
    }
    eixt(0);
}
static void notify_thread(union sigval arg)
{
    ssize_t     n;
    void        *buff;
    printf("notify_thread started\n");
    buff = malloc(attr.mq_msgsize);
    mq_notify(mqd,&sigev);
    while((n = mq_receive(mqd,buff,attr.mq_msgsize,NULL))>=0)
                printf("read %ld bytes\n",(long) n);
    if(errno != EAGAIN)
    {
                perror("mq_receive error");
                exit(-1);
    }
    free(buff);
    pthread_exit(NULL);
}