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

最新推荐文章于 2022-05-01 22:16:16 发布

银灵子Qincheng

最新推荐文章于 2022-05-01 22:16:16 发布

阅读量289

点赞数

本文链接：https://blog.csdn.net/rqc112233/article/details/49990979

版权

UNIX网络编程专栏收录该内容

10 篇文章 0 订阅

订阅专栏

消息队列可以认为是一个消息链表，某个进程往一个消息队列中写入消息之前，不需要另外某个进程在该队列上等待消息的达到，这一点与管道和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