Linux posix消息队列使用详解及注意事项

最新推荐文章于 2024-06-18 22:10:00 发布
最新推荐文章于 2024-06-18 22:10:00 发布
阅读量2.4k 收藏 7
点赞数 1
分类专栏： Linux C快速指南
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rikeyone/article/details/89284916
版权

创建标志

O_CREAT
这个标志是在创建消息队列时需要传入的打开标志。它的含义是，如果该消息队列不存在，那么就创建它，它的隐含含义就是如果该消息队列是存在的，那么O_CREAT不起作用，而仅仅执行打开操作，不会报错。

编译测试代码后重复运行该执行文件，都次都会成功打开，打印如下：

$ ./posix_msq 
[6590] INFO:  mq_open success

O_EXCL
一般这个标志是和O_CREAT一起使用来创建一个消息队列，此时当该消息队列已经存在时，返回错误EEXIST。
测试打印如下：

[6495] ERROR: mq_open error, File exists

这两个场景的测试实例代码：

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <mqueue.h>
#include <fcntl.h>
#include <string.h>
#include "include/debug.h"

#define MSG_QUEUE_NAME "/test_msg_queue"
#define MSG_QUIT "quit"
#define MAX_SIZE 512

int main(int argc, char **argv)
{
    mqd_t mq;
    struct mq_attr attr;
    char buffer[MAX_SIZE + 1];
    int must_stop = 0;

    /* initialize the queue attributes */
    attr.mq_flags = 0;
    attr.mq_maxmsg = 10;
    attr.mq_msgsize = MAX_SIZE;
    attr.mq_curmsgs = 0;

    /* create the message queue */
#if 1
    mq = mq_open(MSG_QUEUE_NAME, O_CREAT | O_RDONLY, 0644, &attr);
#else
    mq = mq_open(MSG_QUEUE_NAME, O_CREAT | O_EXCL | O_RDONLY, 0644, &attr);
#endif
    if ((mqd_t)-1 == mq) {
        err_exit("mq_open error, %s\n", strerror(errno));
	}

    pr_info("mq_open success\n");
    do {
        ssize_t bytes_read;

        /* receive the message */
        bytes_read = mq_receive(mq, buffer, MAX_SIZE, NULL);
        if(bytes_read < 0) {
            err_exit("mq_receive error, %s\n", strerror(errno));
        }

        buffer[bytes_read] = '\0';
        if (!strncmp(buffer, MSG_QUIT, strlen(MSG_QUIT))) {
            must_stop = 1;
        } else {
            pr_info("Received: %s\n", buffer);
        }
    } while (!must_stop);
/*
    if ((mqd_t)-1 == mq_close(mq)) {
        err_exit("mq_close error\n");
    }
    if ((mqd_t)-1 == mq_unlink(MSG_QUEUE_NAME)) {
        err_exit("mq_unlink error\n");
    }
*/

    return 0;
}

接收数据

对于systemv消息队列使用msgrcv来接收数据，如果消息实际长度大于传入要接收的数据时，根据消息标志MSG_NOERROR是否设置，其结果会表现不同。如果接收的消息指定了MSG_NOERROR则说明，不会把这种情况当作错误，而是会主动截断消息长度到接收长度并返回正确。否则该消息不会被接收，而msgrcv直接返回-1，errno设置为E2BIG。

而本文介绍的posix消息队列则大有不同：

ssize_t mq_receive(mqd_t mqdes, char *msg_ptr,
                          size_t msg_len, unsigned int *msg_prio);

对于posix消息队列，使用说明上明确说明了，如果msg_len小于该队列的属性中mq_msgsize的大小值，那么会直接返回-1出错，并且设置errno为EMSGSIZE。同样使用上面的实例代码稍作改动：

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <mqueue.h>
#include <fcntl.h>
#include <string.h>
#include "include/debug.h"

#define MSG_QUEUE_NAME "/test_msg_queue"
#define MSG_QUIT "quit"
#define MAX_SIZE 512

int main(int argc, char **argv)
{
    mqd_t mq;
    struct mq_attr attr;
    char buffer[MAX_SIZE + 1];
    int must_stop = 0;

    /* initialize the queue attributes */
    attr.mq_flags = 0;
    attr.mq_maxmsg = 10;
    attr.mq_msgsize = MAX_SIZE;
    attr.mq_curmsgs = 0;

    /* create the message queue */
    mq = mq_open(MSG_QUEUE_NAME, O_CREAT | O_RDONLY, 0644, &attr);
    if ((mqd_t)-1 == mq) {
        err_exit("mq_open error, %s\n", strerror(errno));
	}

    pr_info("mq_open success\n");
    do {
        ssize_t bytes_read;

        /* receive the message */
        bytes_read = mq_receive(mq, buffer, MAX_SIZE - 1, NULL);
        if(bytes_read < 0) {
            err_exit("mq_receive error, %s\n", strerror(errno));
        }

        buffer[bytes_read] = '\0';
        if (!strncmp(buffer, MSG_QUIT, strlen(MSG_QUIT))) {
            must_stop = 1;
        } else {
            pr_info("Received: %s\n", buffer);
        }
    } while (!must_stop);

    /* cleanup */
    if ((mqd_t)-1 == mq_close(mq)) {
        err_exit("mq_close error\n");
    }
    if ((mqd_t)-1 == mq_unlink(MSG_QUEUE_NAME)) {
        err_exit("mq_unlink error\n");
    }


    return 0;
}

这里把接收时传入的参数为MAX_SIZE - 1， 小于消息队列属性值大小，运行打印如下：

[6661] INFO:  mq_open success
[6661] ERROR: mq_receive error, Message too long

关闭与删除

mq_close只是用来关闭一个进程中使用的消息队列描述符，消息队列本身依然存在，其中的消息也都会保存。
mq_unlink用于删除消息队列的name，如果存在打开的描述符，那么该消息队列依然可用，直到所有打开的描述符都关闭后才会destory，这一点需要特别注意。

测试实例：

server:

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <mqueue.h>
#include <fcntl.h>
#include <string.h>
#include <time.h>
#include "include/debug.h"

#define MSG_QUEUE_NAME "/test_msg_queue"
#define MSG_QUIT "quit"
#define MAX_SIZE 512

int main(int argc, char **argv)
{
    mqd_t mq;
    struct mq_attr attr;
    char buffer[MAX_SIZE + 1];
    int must_stop = 0;

    /* initialize the queue attributes */
    attr.mq_flags = 0;
    attr.mq_maxmsg = 10;
    attr.mq_msgsize = MAX_SIZE;
    attr.mq_curmsgs = 0;

    /* create the message queue */
    mq = mq_open(MSG_QUEUE_NAME, O_CREAT | O_RDONLY, 0644, &attr);
    if ((mqd_t)-1 == mq) {
        err_exit("mq_open error, %s\n", strerror(errno));
	}

    pr_info("mq_open success\n");
    do {
        ssize_t bytes_read;

        pr_info("start received...\n");
        /* receive the message */

        bytes_read = mq_receive(mq, buffer, MAX_SIZE, NULL);
        if(bytes_read < 0) {
            err_exit("mq_receive error, %s\n", strerror(errno));
        }
        buffer[bytes_read] = '\0';
        if (!strncmp(buffer, MSG_QUIT, strlen(MSG_QUIT))) {
            must_stop = 1;
        } else {
            pr_info("Received: %s\n", buffer);
        }
    } while (!must_stop);

    /* cleanup */
    if ((mqd_t)-1 == mq_close(mq)) {
        err_exit("mq_close error\n");
    }
    if ((mqd_t)-1 == mq_unlink(MSG_QUEUE_NAME)) {
        err_exit("mq_unlink error\n");
    }


    return 0;
}


client:
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <string.h>
#include <mqueue.h>
#include "include/debug.h"

#define MSG_QUEUE_NAME "/test_msg_queue"
#define MSG_QUIT "quit"
#define MAX_SIZE 512

int main(int argc, char **argv)
{
    mqd_t mq;

    if (argc < 2)
        err_exit("need an argument as message\n");

    /* open the mail queue */
    mq = mq_open(MSG_QUEUE_NAME, O_WRONLY);
    if ((mqd_t)-1 == mq) {
        err_exit("mq_open error, %s\n", strerror(errno));
    }

    pr_info("mq_open success\n");

    /* send the message */
    if (0 < mq_send(mq, argv[1], strlen(argv[1]), 0)) {
        err_exit("mq_send error,%s\n", strerror(errno));
    }

    /* cleanup */
#if 0 
    if ((mqd_t)-1 == mq_close(mq)){
        err_exit("mq_close error, %s\n", strerror(errno));
    }
#else
    if (-1 == mq_unlink(MSG_QUEUE_NAME)){
        err_exit("mq_unlink error, %s\n", strerror(errno));
    }
    if (0 < mq_send(mq, argv[1], strlen(argv[1]), 0)) {
        err_exit("mq_send error,%s\n", strerror(errno));
    }
#endif

    return 0;
}

最后server在unlink后依然可以接收到数据：

[8222] INFO:  mq_open success
[8222] INFO:  start received...
[8222] INFO:  Received: 123
[8222] INFO:  start received...
[8222] INFO:  Received: 123
[8222] INFO:  start received...

多线程中的操作

情形1：多线程环境中，一个线程1正在阻塞读，另一个线程2使用mq_close关闭了描述符，那么会对其有什么影响呢？
实测发现，虽然该消息队列实际已经关闭，但这种情况不会打断线程1的阻塞状态。

[8502] INFO:  mq_open success
[8502] INFO:  start received...
[8502] INFO:  close mq descriptor now!

情形2：线程1使用timeout接口或者nonblock方式重复读消息队列，另一个线程2使用mq_close关闭了描述符，那么会对其有什么影响呢？
这种情况下，线程1在关闭描述符后再次读取时会报错返回。

[8514] INFO:  mq_open success
[8514] INFO:  start received...
[8514] INFO:  tv_sec:1555164263 tv_nsec:724058183
[8514] INFO:  mq_timedreceive timeout
[8514] INFO:  tv_sec:1555164266 tv_nsec:724172113
[8514] INFO:  mq_timedreceive timeout
[8514] INFO:  tv_sec:1555164269 tv_nsec:724316674
[8514] INFO:  mq_timedreceive timeout
[8514] INFO:  tv_sec:1555164272 tv_nsec:724467855
[8514] INFO:  close mq descriptor now!
[8514] INFO:  mq_timedreceive timeout
[8514] INFO:  tv_sec:1555164275 tv_nsec:724606740
[8514] ERROR: mq_receive error, Bad file descriptor

测试代码如下:

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <mqueue.h>
#include <fcntl.h>
#include <string.h>
#include <pthread.h>
#include <time.h>
#include "include/debug.h"

#define MSG_QUEUE_NAME "/test_msg_queue"
#define MSG_QUIT "quit"
#define MAX_SIZE 512

static mqd_t mq;

void *thr_fn(void *arg)
{
    sleep(10);
    pr_info("close mq descriptor now!\n");
    /* cleanup */
    if ((mqd_t)-1 == mq_close(mq)) {
        err_exit("mq_close error\n");
    }
	return(0);
}

int mq_receive_timeout(mqd_t mq, char *buf, int len, int second)
{
    int bytes_read;
    struct timespec timeout;

    do {
        clock_gettime(CLOCK_REALTIME, &timeout);
        pr_info("tv_sec:%ld tv_nsec:%ld\n",
                    timeout.tv_sec,
                    timeout.tv_nsec);
        timeout.tv_sec += second;
        bytes_read = mq_timedreceive(mq, buf, len, NULL, &timeout);
        if(bytes_read < 0) {
            if (errno != ETIMEDOUT)
                err_exit("mq_receive error, %s\n", strerror(errno));
            else
                pr_info("mq_timedreceive timeout\n");
        } else if (bytes_read > 0)
            break;
    } while(1);

    return bytes_read;
}


int main(int argc, char **argv)
{
    struct mq_attr attr;
    char buffer[MAX_SIZE + 1];
    int must_stop = 0, err;
    pthread_t	tid;

    /* initialize the queue attributes */
    attr.mq_flags = 0;
    attr.mq_maxmsg = 10;
    attr.mq_msgsize = MAX_SIZE;
    attr.mq_curmsgs = 0;

    /* create the message queue */
    mq = mq_open(MSG_QUEUE_NAME, O_CREAT | O_RDONLY, 0644, &attr);
    if ((mqd_t)-1 == mq) {
        err_exit("mq_open error, %s\n", strerror(errno));
	}

	/*
	 * Create a child thread
	 */
	err = pthread_create(&tid, NULL, thr_fn, 0);
	if (err != 0)
		err_exit("can't create thread\n");

    pr_info("mq_open success\n");
    do {
        ssize_t bytes_read;

        pr_info("start received...\n");
        /* receive the message */
#if 1
        bytes_read = mq_receive_timeout(mq, buffer, MAX_SIZE, 3);
        if(bytes_read < 0) {
            err_exit("mq_receive error, %s\n", strerror(errno));
        }
#else
        bytes_read = mq_receive(mq, buffer, MAX_SIZE, NULL);
        if(bytes_read < 0) {
            err_exit("mq_receive error, %s\n", strerror(errno));
        }
#endif
        buffer[bytes_read] = '\0';
        if (!strncmp(buffer, MSG_QUIT, strlen(MSG_QUIT))) {
            must_stop = 1;
        } else {
            pr_info("Received: %s\n", buffer);
        }
    } while (!must_stop);

    /* cleanup */
    if ((mqd_t)-1 == mq_close(mq)) {
        err_exit("mq_close error\n");
    }
    if ((mqd_t)-1 == mq_unlink(MSG_QUEUE_NAME)) {
        err_exit("mq_unlink error\n");
    }


    return 0;
}
程序猿Ricky的日常干货
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实现posix消息队列示例分享
09-04
POSIX消息队列是一种在进程间通信（IPC）机制，允许不同进程之间交换结构化数据。在本示例中，我们将深入理解如何实现一个POSIX消息队列，并探讨相关的概念和技术，包括线程同步机制、内存映射以及信号处理。 首先...
mqueue:一个为windows获取POSIX消息队列的实验项目
06-04
4. **使用第三方库**：也有可能是借助第三方库，如libpqxx（一个C++封装的POSIX消息队列库），来在Windows上提供POSIX消息队列的兼容性。 在项目“mqueue-master”中，我们可能看到以下内容： - **源代码文件**：...
mq_open函数打开失败原因
爱柚柚的老板的博客
11-28 5030
最近在看IPC，自己在编写Posix消息队列时，遇到mq_open无法打开，总是返回错误。因为在posix标准中，并不是所有的名字都可以使用，必须是以 / 开始，并且名字里只能包含一个 / 。 代码如下，如果使用NAME ，输出success。如果使用NAME1，输出erro #include &lt;stdlib.h&gt; #include &lt;sys/stat.h&gt; #inc...
Linux 进程间通信之消息队列的几点注意事项
白永辉的专栏
03-29 1535
1. 由于消息队列是属于内核的，因此在执行时，必须有Root权限才可以，否则会在访问消息队列时，出现EACCES错误，即访问权限的问题 2. msgbuf.mtype的设置 int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); msgp指向结构体： struct msgbuf {
【ARM-Linux篇】POSIX消息队列
最新发布
m0_66492811的博客
06-18 1155
POSIX消息队列
细说linux IPC（九）：posix消息队列
程序猿的挨踢人生
12-05 7593
【版权声明：尊重原创，转载请保留出处：blog.csdn.net/shallnet 或 .../gentleliu，文章仅供学习交流，请勿用于商业用途】         消息队列可以看作一系列消息组织成的链表，一个程序可以往这个链表添加消息，另外的程序可以从这个消息链表读走消息。 mq_open()函数打开或创建一个posix消息队列。 #inclu
linux网络编程之POSIX消息队列
Chenk的专栏
09-26 1614
POSIX IPC名字限定： 必须以/打头，并且后续不能有其它/ ，形如/somename 长度不能超过NAME_MAX   通过下面的命令将消息队列挂载到/dev/mqueue下，可通过cat/dev/mqueue/name查看消息队列状态 mount -t mqueue none /dev/mqueue mq_open函数： 功能：用来创建和访问一个消息队列 原型 mqd_t
linux posix消息队列
紫枫洛天的博客
06-19 174
1 基本概念 消息队列具有随内核的持续性，也就是系统不重启，消息队列永久存在。 mq_send和mq_receive是阻塞进行调用, 所以发送端调用mq_send有可能不成功, 因为接收端没调用mq_receive
Linux应用开发（7）：Linux进程间通信（IPC）：POSIX消息队列
tecsai的博客
04-17 1049
消息队列是Linux提供进程间通信的一种方式。当多个进程需要共享或交换数据时，就会用到消息队列。此外，消息队列还可以作为一个缓冲区，可以在处理速度不同的进程间提供数据交换。
msg.zip_LINUX消息队列_linux 消息队列
09-22
在Linux中，消息队列的实现主要依赖于System V IPC（System V Interprocess Communication）或POSIX消息队列，两者都提供了API供用户使用。 压缩包中的单个文件"msg"可能是源代码文件，包含了用C语言或者C++编写的...
进程间通信之深入消息队列的详解
01-20
在Linux系统中，有两种主要的消息队列实现：POSIX消息队列和System V消息队列。System V消息队列是较早的实现，它允许消息队列在内核重启后仍然存在，除非手动删除。而POSIX消息队列则更加标准化，符合POSIX标准。 ...
linux posix消息队列测试
weixin_41306984的博客
04-16 296
如果之前消息队列里面有一些消息，先正常接收，，消息队列中的字节数越来越小，收完了就会显示接收失败。从下面运行情况可以看出，在没有接收程序的情况下，发送满10条后就发送失败，是非阻塞的。从消息队列文件中可以看出里面的字节数不断增长，字节数等于每次的字节数8*发送次数。打开消息队列的函数中设置O_NONBLOCK，那么发送和接收函数都是非阻塞的。如果不同时间段分别启动3个发送程序，可以看出收到的消息的优先级是3个不同的。因为发送程序发送的时候是带优先级的，下面函数的最后一个参数i是变的。从下面看接收是阻塞的。
Linux进程间通信(IPC) Linux消息队列：讲解POSIX消息队列在Linux系统进程间通信中的应用和实践
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
03-10 2060
posix消息队列的使用
linux下消息队列使用
jinlei2009
05-17 1045
这几天在学习消息队列使用，终于编写了一个简单的测试程序，拿出来与大家分享下：   /****************************************************************************** 版权所有 (C), 2001-2011, ******************************
posix消息队列概述以及限制
weixin_34245749的博客
09-19 118
2019独角兽企业重金招聘Python工程师标准>>> ...
Posix消息队列
qq_22753933的博客
03-15 160
//发送消息 #include &amp;lt;unistd.h&amp;gt; #include &amp;lt;sys/types.h&amp;gt; #include &amp;lt;fcntl.h&amp;gt; #include &amp;lt;sys/stat.h&amp;gt; #include &amp;lt;mqueue.h&amp;gt; #include &amp;lt;stdlib
Linux进程间通信之POSIX消息队列
rotation博客
07-30 3308
消息队列可认为是一个消息链表，它允许进程之间以消息的形式交换数据。有足够写权限的进程或线程可往队列中放置消息，有足够读权限的进程或线程可从队列中取走消息。每个消息都是一个记录，它由发送者赋予一个优先级。与管道不同，管道是字节流模型，没有消息边界。 本文介绍的是POSIX消息队列。POSIX消息队列与System V消息队列的相似之处在于数据的交换单位是整个消息，但它们之间仍然存在一些显著的差异。
Linux——POSIX 消息队列
0 error(s)
04-08 492
文章目录什么是消息队列打开 | 关闭 | 删除 消息队列：mq_open、mq_close和mq_unlink获取 | 查看 属性：mq_getattr和mq_setattr消息发送和接受函数：mq_send和mq_receive消息队列的限制消息队列通知函数：mq_notify 写在前面：此系列主要参考自UNIX网络编程-卷2-进程间通信，将会有大量demo。 书籍链接：微云链接 什么是消息队列 消息队列可认为是一个消息链表。有写权限的线程可以往队列中放置消息，有读权限的线程可以从队列中取走消息，每个消息
Linux POSIX Message Queue 使用体会
风海流的豪赌
06-08 4034
最近正在Linux上使用POSIX Message Queue（以下简称MQ）在进程间通讯，对目前我这系统发行版和编译器来讲，MQ用起来有一点体会，是教程是没有说明的，或者我看的不够仔细，没有发现 参考资料 《The Linux Programming Interface - A Linux and UNIX System Programming Handbook》2010
linux posix消息队列例程
03-25
下面是一个简单的Linux POSIX消息队列的例程，包括创建、发送、接收和删除消息队列。 ```c++ #include #include #include #include #include #include #include #define MSG_SIZE 1024 #define QUEUE_NAME ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值