IPC通信:Posix消息队列读,写

创建消息队列的程序:

#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 FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) // 设定创建MQ的权限

int main()

{
mqd_t posixmq;
int rc = 0;

/*
函数说明：函数创建或打开一个消息队列
返回值：成功返回消息队列描述符，失败返回-1，错误原因存于errno中
*/
posixmq = mq_open(MQ_NAME, MQ_FLAG, FILE_MODE, NULL);

if(-1 == posixmq)
{
perror("创建MQ失败");
exit(1);
}

/*
函数说明：关闭一个打开的消息队列，表示本进程不再对该消息队列读写
返回值：成功返回0，失败返回-1，错误原因存于errno中
*/
rc = mq_close(posixmq);
if(0 != rc)
{
perror("关闭失败");
exit(1);
}

#if 0
/*
函数说明：删除一个消息队列，好比删除一个文件，其他进程再也无法访问
返回值：成功返回0，失败返回-1，错误原因存于errno中
*/
rc = mq_unlink(MQ_NAME);
if(0 != rc)
{
perror("删除失败");
exit(1);
}

return 0;
#endif
}

编译并执行：

root@linux:/mnt/hgfs/C_libary# gcc -o crtmq crtmq.c -lrt
root@linux:/mnt/hgfs/C_libary# ./crtmq
程序并没有删除消息队列（消息队列有随内核持续性），如再次执行该程序则会给出错误信息：
root@linux:/mnt/hgfs/C_libary# ./crtmq
创建MQ失败: File  exit(0)

向消息队列写消息的程序：

消息队列的读写主要使用下面两个函数：
/*头文件*/
#include <mqueue.h>

/*返回：若成功则为消息中字节数，若出错则为-1 */
int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio);

/*返回：若成功则为0， 若出错则为-1*/
ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio);

/*消息队列属性结构体*/
struct mq_attr {
long mq_flags;       /* Flags: 0 or O_NONBLOCK */
long mq_maxmsg;      /* Max. # of messages on queue */
long mq_msgsize;     /* Max. message size (bytes) */
long mq_curmsgs;     /* # of messages currently in queue */
};

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

/*向消息队列发送消息，消息队列名及发送的信息通过参数传递*/
int main(int argc, char *argv[])
{
mqd_t mqd;
char *ptr;
size_t len;
unsigned int prio;
int rc;

if(argc != 4)
{
printf("Usage: sendmq <name> <bytes> <priority>\n");
exit(1);
}

len = atoi(argv[2]);
prio = atoi(argv[3]);

//只写模式找开消息队列
mqd = mq_open(argv[1], O_WRONLY);
if(-1 == mqd)
{
perror("打开消息队列失败");
exit(1);
}

// 动态申请一块内存
ptr = (char *) calloc(len, sizeof(char));
if(NULL == ptr)
{
perror("申请内存失败");
mq_close(mqd);
exit(1);
}

/*向消息队列写入消息，如消息队列满则阻塞，直到消息队列有空闲时再写入*/
rc = mq_send(mqd, ptr, len, prio);
if(rc < 0)
{
perror("写入消息队列失败");
mq_close(mqd);
exit(1);
}

// 释放内存
free(ptr);
return 0;
}

编译并执行：

root@linux:/mnt/hgfs/C_libary# gcc -o sendmq sendmq.c -lrt
root@linux:/mnt/hgfs/C_libary# ./sendmq /tmp 30 15
root@linux:/mnt/hgfs/C_libary# ./sendmq /tmp 30 16
root@linux:/mnt/hgfs/C_libary# ./sendmq /tmp 30 17
root@linux:/mnt/hgfs/C_libary# ./sendmq /tmp 30 18

　　上面先后向消息队列“/tmp”写入了四条消息，因为先前创建的消息队列只允许存放3条消息，本次第四次写入时程序会阻塞。直到有另外进程从消息队列取走消息后本次写入才成功返回。

读消息队列：

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

/*读取某消息队列,消息队列名通过参数传递*/
int main(int argc, char *argv[])
{
mqd_t mqd;
struct mq_attr attr;
char *ptr;
unsigned int prio;
size_t n;
int rc;

if(argc != 2)
{
printf("Usage: readmq <name>\n");
exit(1);
}

/*只读模式打开消息队列*/
mqd = mq_open(argv[1], O_RDONLY);
if(mqd < 0)
{
perror("打开消息队列失败");
exit(1);
}

// 取得消息队列属性，根据mq_msgsize动态申请内存
rc = mq_getattr(mqd, &attr);
if(rc < 0)
{
perror("取得消息队列属性失败");
exit(1);
}

/*动态申请保证能存放单条消息的内存*/
ptr = 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);
return 0;
}

编译并执行：

root@linux:/mnt/hgfs/C_libary# vi readmq.c
root@linux:/mnt/hgfs/C_libary# vi readmq.c
root@linux:/mnt/hgfs/C_libary# gcc -o readmq readmq.c -lrt
root@linux:/mnt/hgfs/C_libary# ./readmq /tmp
读取 30 字节
优先级为 18
root@linux:/mnt/hgfs/C_libary# ./readmq /tmp
读取 30 字节
优先级为 17
root@linux:/mnt/hgfs/C_libary# ./readmq /tmp
读取 30 字节
优先级为 16
root@linux:/mnt/hgfs/C_libary# ./readmq /tmp
读取 30 字节
优先级为 15
root@linux:/mnt/hgfs/C_libary# ./readmq /tmp

　　程序执行五次，第一次执行完，先前阻塞在写处的程序成功返回。第五次执行，因为消息队列已经为空，程序阻塞。直到另外的进程向消息队列写入一条消息。另外，还可以看出Posix消息队列每次读出的都是消息队列中优先级最高的消息。