UNIX网络编程——Posix 消息队列

来源：互联网发布：七子之歌知乎编辑：程序博客网时间：2024/06/05 03:07

消息队列可以认为是一个消息链表，某个进程往一个消息队列中写入消息之前，不需要另外某个进程在该队列上等待消息的达到，这一点与管道和FIFO相反。

消息队列是随着内核的持续性的，而管道只是随着进程的持续性。这意味着管道在进程结束时，留在管道内的数据将会被丢弃。

Posix消息队列与System V消息队列的区别如下：
1. 对Posix消息队列的读总是返回最高优先级的最早消息，对System V消息队列的读则可以返回任意指定优先级的消息。
2. 当往一个空队列放置一个消息时，Posix消息队列允许产生一个信号或启动一个线程，System V消息队列则不提供类似的机制。

队列的操作函数：

#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;

看下面一个例子：写入消息队列中

#include <stdio.h>  #include <stdlib.h> #include <mqueue.h>   //头文件#include <sys/types.h>  #include <sys/stat.h>  #include <unistd.h>  #include <fcntl.h>  #include <errno.h>   #define MQ_NAME ("./tmp")  #define MQ_FLAG (O_RDWR | O_CREAT | O_EXCL) // 创建MQ的flag #define MQ_FLAG (O_RDWR | O_CREAT | O_EXCL) #define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) // 设定创建MQ的权限   #define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)int main()  {      mqd_t posixmq,mqd;      int rc = 0;      posixmq = mq_open(MQ_NAME, MQ_FLAG, FILE_MODE, NULL);      if(-1 == posixmq)       {          perror("创建MQ失败");           exit(1);       }        rc = mq_close(posixmq);       if(0 != rc)       {           perror("关闭失败");           exit(1);       }      mqd = mq_open(MQ_NAME, O_WRONLY);      if(-1 == mqd)      {          perror("打开消息队列失败");          exit(1);      }  int len=3; char *ptr = (char *) calloc(len, sizeof(char)); if(NULL == ptr){perror("申请内存失败"); mq_close(mqd); exit(1);  }unsigned int prio=1;rc = mq_send(mqd, ptr, len, prio); if(rc<0){perror("写入数据失败");mq_close(mqd); exit(1);}free(ptr); exit(0);  }

读出消息队列：

#include <stdio.h>  #include <stdlib.h>  #include <mqueue.h>  #include <sys/types.h>  #include <sys/stat.h>  #include <unistd.h>  #include <fcntl.h>  #include <errno.h> #define MQ_NAME ("./tmp")  int main()  {      mqd_t mqd;      struct mq_attr attr;      char *ptr;      unsigned int prio;      size_t n;      int rc;      /*只读模式打开消息队列*/     mqd = mq_open(MQ_NAME, O_RDONLY);      if(mqd < 0)      {          perror("打开消息队列失败");          exit(1);      }         // 取得消息队列属性，根据mq_msgsize动态申请内存      rc = mq_getattr(mqd, &attr);      if(rc < 0)      {          perror("取得消息队列属性失败");          exit(1);      }      /*动态申请保证能存放单条消息的内存*/     ptr = (char*)calloc(attr.mq_msgsize, sizeof(char));      if(NULL == ptr)      {          printf("动态申请内存失败\n");          mq_close(mqd);          exit(1);      }         /*接收一条消息*/     n = mq_receive(mqd, ptr, attr.mq_msgsize, &prio);      if(n < 0)      {          perror("读取失败");          mq_close(mqd);          free(ptr);          exit(1);      }          printf("读取 %ld 字节\n  优先级为 %u\n", (long)n, prio);         exit(0);  }

在进行编译时需要加上： g++ -o read read.cpp -lrt（类似这样编译）

当消息队列里面写满了信息，再往里面写会阻塞进程，空的消息队列，如果读取的话，也会阻塞消息队列。

下面看两个程序：一个是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);}

好了，这里面涉及了很多的信号函数，具体的链接地址：http://blog.csdn.net/xiaocainiaoshangxiao/article/details/18093569

部分代码引用来源：http://www.cnblogs.com/Anker/archive/2013/01/04/2843832.html

0 0