【从浅学到熟知Linux】进程间通信之消息队列（含消息队列的特点，msgget/msgsnd/msgrcv/msgtrl接口使用详解、消息队列实现Client&Server）

最新推荐文章于 2024-05-04 07:00:00 发布
最新推荐文章于 2024-05-04 07:00:00 发布
阅读量1.4k 收藏 19
点赞数 31
分类专栏： 从浅学到熟知Linux 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66926829/article/details/138193175
版权

在这里插入图片描述

🏠关于专栏：Linux的浅学到熟知专栏用于记录Linux系统编程、网络编程等内容。
🎯每天努力一点点，技术变化看得见

文章目录

消息队列的引入

在我们之前的讨论的匿名管道、命名管道、共享内存中，我们可以不可以实现两个通信进程向同一个共享资源进行写入或读取呢？答案是否定的。从专栏前几篇文章介绍可知，上述三种方式主要用于单向通信，如果通过一些控制策略，则可以实现半双工通信。

为了实现两个进程互相收发消息时使用同一资源，我们就有了消息队列。消息队列是一种在不同进程或者不同系统之间进行通信的机制，它是一种存放消息的容器，发送方向队列中发送消息，接收方从队列中接收消息。下面是消息队列的大致原理：

创建消息队列：首先需要创建一个消息队列，通常由消息队列服务程序负责管理，进程可以通过调用相关API来进行消息队列的创建。

发送消息：发送方将待发送的消息写入到消息队列中，消息包括消息类型和消息。发送方通过指定消息队列的标识符和消息类型来发送消息。

接收消息：接收方从消息队列中获取消息，根据消息类型进行消息过滤或选择性接收。接收方通过指定消息队列的标识符和消息类型来接收消息。

在这里插入图片描述

系统中可能存在大量的消息队列，内核需要使用如下数据结构对消息队列进行管理↓↓↓

struct msqid_ds {
    struct ipc_perm msg_perm;     /* Ownership and permissions */
    time_t          msg_stime;    /* Time of last msgsnd(2) */
    time_t          msg_rtime;    /* Time of last msgrcv(2) */
    time_t          msg_ctime;    /* Time of last change */
    unsigned long   __msg_cbytes; /* Current number of bytes in
                                     queue (nonstandard) */
    msgqnum_t       msg_qnum;     /* Current number of messages
                                     in queue */
    msglen_t        msg_qbytes;   /* Maximum number of bytes
                                     allowed in queue */
    pid_t           msg_lspid;    /* PID of last msgsnd(2) */
    pid_t           msg_lrpid;    /* PID of last msgrcv(2) */
};

struct ipc_perm {
    key_t          __key;       /* Key supplied to msgget(2) */
    uid_t          uid;         /* Effective UID of owner */
    gid_t          gid;         /* Effective GID of owner */
    uid_t          cuid;        /* Effective UID of creator */
    gid_t          cgid;        /* Effective GID of creator */
    unsigned short mode;        /* Permissions */
    unsigned short __seq;       /* Sequence number */
};

消息队列接口及使用示例

msgget

在这里插入图片描述
第一个参数key需要使用ftok函数接口生成，这个函数具体用法在[共享内存传送门]文章中有介绍。第二个参数可以选择一下几种常用选项↓↓↓

msgflg取值描述
IPC_CRAET创建共享内存时，如果共享内存已经已经存在，获取已经存在的共享内存；不存在则创建并返回
IPC_EXCL需要与IPC_CREAT组合使用，单独使用没有意义。如果带创建的共享内存存在，则出错返回；如果不存在，则创建并返回对应的共享内存

作为读写资源的一种，消息队列也有自己的读写权限，可以通过上述第二个参数与运算对应的权限即可，如第二个参数可以填写IPC_CREAT | 0666（其中0666就表示设置的权限）。

下面代码创建了一个消息队列↓↓↓

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int main()
{
    key_t key = ftok("/home/xiaoming", 777);
    int msgid = msgget(key, IPC_CREAT | 0666);
    return 0;
}

我们可以借助ipcs -q查看系统中存在的消息队列，下图为创建前后创建后的情况↓↓↓
在这里插入图片描述
ipcs -q的各个字段中，key是我们创建消息队列时传入的，msqid是系统自动生成的标识消息队列唯一性的符号，owner是该消息队列的所有者，perms是该消息队列的权限，used_types表示消息队列已经使用的空间大小，messages表示消息队列中的消息数量。

msgsnd&&msgrcv

在这里插入图片描述
在msgsnd和msgrcv中，第二个参数需要传入一个形式如下所示的结构体，这个结构体需要用户自己定义（msgsnd用该结构体定义要发送的数据，msgrcv用该结构体接收消息队列中的数据）↓↓↓

The msgp argument is a pointer to caller-defined structure of the following general form:

struct msgbuf {
    long mtype;       /* message type, must be > 0 */
    char mtext[1];    /* message data */
};

上述中的mtext表示要发送的数据，因而mtext的数组大小由用户自己指定；而mtype用于标识数据，例如：A进程只读取mtype为1的数据，B进程只读取mtype为2的数据，即mtype标识这个数据要发送给哪些进程。

msgsnd的第一个参数表示向哪一个消息队列中发送，需要传入能够标识队列唯一性的msgid；第三个参数msgsz用于标识msgbuf中的mtext的大小，即数据的大小；msgsnd中的msgflg的取值及含义如下表所示↓↓↓

msgflg取值含义
0默认行为，阻塞等待消息队列，直到消息队列中有空间
IPC_NOWAIT如果队列已满，不会阻塞等待，而是会返回错误码EAGAIN（设置在errno中）

msgrcv的第一个参数也是用于表示向哪一个消息队列中发送，需要传入具有唯一性的msgid；第三个参数msgsz表示用于接收数据的msgbuf中的mtext的大小，即接收缓冲区的大小（如果接收缓冲区的大小小于发送过来的数据，则会出错）；第四个参数msgtyp表示只接收消息队列中msgbuf的mtype字段为msgtyp的数据；msgrcv中的msgflg的取值及含义如下表所示↓↓↓

msgflg取值含义
0默认行为，阻塞等待消息队列，直到消息队列中有满足需求的数据
IPC_NOWAIT非阻塞等待消息队列，如果队列中没有对应需求的数据，则errno设置为ENOMSG，并返回
MSG_EXCEPT接收队列中msgbuf中的mtype不为msgtyp的数据
MSG_NOERROR如果数据的长度长于接收方的msgbuf的mtext大小，则会发生截断，余下数据被丢弃

msgsnd.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#define MAX_SIZE 1024

struct msgbuf
{
    long mtype;
    char mtext[MAX_SIZE];
};

int main()
{
    key_t key = ftok("/home/xiaoming", 777);
    int msgid = msgget(key, IPC_CREAT | 0666);

    char *sendmsg = "Jammingpro";
    struct msgbuf buffer;
    buffer.mtype = 1;
    snprintf(buffer.mtext, MAX_SIZE, "%s", sendmsg);

    msgsnd(msgid, &buffer, MAX_SIZE, 0);

    return 0;
}

msgrcv.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#define MAX_SIZE 1024

struct msgbuf
{
    long mtype;
    char mtext[MAX_SIZE];
};

int main()
{
    key_t key = ftok("/home/xiaoming", 777);
    int msgid = msgget(key, IPC_CREAT | 0666);

    struct msgbuf buffer;

    if (msgrcv(msgid, &buffer, MAX_SIZE, 1, 0) == -1)
    {
        perror("msgcrv error");
        exit(0);
    }

    printf("%s\n", buffer.mtext);

    return 0;
}

在这里插入图片描述

msgctl

在这里插入图片描述
msgctl的第一个参数表示对哪一个消息队列进行操作，第二个参数的取值和描述如下标所示↓↓↓

cmd取值含义
IPC_STAT获取消息队列的状态
IPC_SET设置消息队列的属性
IPC_RMID从系统中移除消息队列

系统中管理消息队列时，维护了一个msgid_ds的结构，如果需要设置或获取某个新消息队列，需要创建一个struct msqid_ds类型的变量，将其传入第三个参数中。

下面代码演示了如何获取消息队列的状态↓↓↓
msgctl-stat.c

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int main()
{
    key_t key = ftok("/home/xiaoming", 888);
    int msgid = msgget(key, IPC_CREAT | 0666);

    sleep(2);

    struct msqid_ds mqs;
    memset(&mqs, 0, sizeof(mqs));

    msgctl(msgid, IPC_STAT, &mqs);

    printf("num:    %d\n", mqs.msg_qnum);
    printf("bytes:  %d\n", mqs.msg_qbytes);

    return 0;
}

在这里插入图片描述
下面代码演示了如何设置消息队列的状态↓↓↓
msgctl-set.c

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int main()
{
    key_t key = ftok("/home/xiaoming", 888);
    int msgid = msgget(key, IPC_CREAT | 0666);

    sleep(2);

    struct msqid_ds mqs;
    memset(&mqs, 0, sizeof(mqs));

    mqs.msg_perm.mode = 0444;
    msgctl(msgid, IPC_SET, &mqs);

    return 0;
}

在这里插入图片描述
下面代码演示了如何删除消息队列↓↓↓
msgctl-rm.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int main()
{
    key_t key = ftok("/home/xiaoming", 888);
    int msgid = msgget(key, IPC_CREAT);

    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

在这里插入图片描述

消息队列的特点

  1. 异步通信：发送者和接收者之间的通信是异步的，发送者可以继续执行其他操作而不用等待接收者处理消息。

  2. 独立性：消息队列是独立于发送者和接收者的，发送者和接收者之间可以是不同的进程，甚至可以在不同的计算机上。

  3. 顺序性保证：消息队列通常是一种先进先出（FIFO）的数据结构，保证消息的顺序性。

  4. 灵活性：消息队列可以传递多种类型的数据，而且消息的大小通常也比较灵活。

  5. 缓冲能力：消息队列可以作为缓冲区，当接收者暂时无法处理消息时，消息可以先存储在消息队列中，等待接收者处理。

  6. 可靠性：消息队列通常会提供一定的机制来确保消息的可靠性，例如消息确认和消息重发机制。

  7. 支持半双工通信：相比于匿名/命名管道及共享内存的单向通信特征，消息队列具备半双工通信的能力。

消息队列——实现Client&Server

由于struct msgbuf中的mtype可以标识向那个进程发送消息。假设Server接收mtype为1的数据↓↓↓

Com.hpp

#pragma once
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

const std::string PATH = "/home/xiaoming";
const int PROJ_ID = 999;
const int BUFF_SIZE = 1024;

enum
{
    MSG_CREAT_ERR = 1,
    MSG_GET_ERR,
    MSG_DELETE_ERR
};

int CreateMsg()
{
    key_t key = ftok(PATH.c_str(), PROJ_ID);
    int msgid = msgget(key, IPC_CREAT | IPC_EXCL | 0666);
    if (msgid < 0)
    {
        perror("msg create error");
        exit(MSG_CREAT_ERR);
    }
    return msgid;
}

int GetMsg()
{
    key_t key = ftok(PATH.c_str(), PROJ_ID);
    int msgid = msgget(key, IPC_CREAT | 0666);
    if (msgid < 0)
    {
        perror("msg get error");
        exit(MSG_GET_ERR);
    }
    return msgid;
}

Server.cc

#include "Com.hpp"

int main()
{
    struct msgbuf buffer;
    int msgid = CreateMsg();
    while (true)
    {
        msgrcv(msgid, &buffer, BUFF_SIZE, 1, 0);
        std::cout << "Client say@ " << buffer.mtext << std::endl;
    }
    return 0;
}

Client.cc

#include "Com.hpp"

int main()
{
    int msgid = GetMsg();
    struct msgbuf buffer;
    buffer.mtype = 1;
    while (true)
    {
        std::cout << "Says # ";
        std::string s;
        std::getline(std::cin, s);
        strcpy(buffer.mtext, s.c_str());
        msgsnd(msgid, &buffer, BUFF_SIZE, 0);
    }
    return 0;
}

在这里插入图片描述

🎈欢迎进入从浅学到熟知Linux专栏，查看更多文章。
如果上述内容有任何问题，欢迎在下方留言区指正b(￣▽￣)d

Jammingpro
关注
  • 31
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程间通信之---消息队列
weixin_45897952的博客
03-19 3016
目录 消息队列 1.消息队列的原理 2.消息队列的接口: 2.1创建消息队列 2.2向消息队列发送消息 2.3接收消息： 2.4操作消息队列的接口 2.5代码测试： 信号量: 信号量的原理 消息队列 1.消息队列的原理 1.1 msgqueue采用链表来实现消息队列， 该链表是由系统内核维护， 1.2 系统中可能有很多的msgqueue, 每个MQ用消息队列描述符(消息队列ID: qid) 来区分，qid是唯一 的，用来区分不同的MQ..
跟我学linux-入门级教程
12-31
非常好的教程,浅学易懂,主要是基于centos的讲解
Linux进程通信之消息队列
m0_60010936的博客
11-27 4054
Linux 消息队列
Linux POSIX消息队列遇到的问题和使用方法
最新发布
weixin_46158019的博客
05-04 1142
开发板：nuc9801.ARM Linux中消息队列的原理在ARM Linux中，消息队列是通过POSIX（Portable Operating System Interface）标准实现的。消息队列在内核中维护，通过文件系统（如/dev/mqueue）或系统调用来访问。消息队列具有以下几个主要特点异步通信：发送进程和接收进程不需要同时处于活动状态。发送进程可以将消息放入队列，然后继续进行其他操作；接收进程可以在需要时从队列中取出消息。消息独立性：队列中的每个消息都是独立的，拥有自己的属性和内容。顺序性。
Linux--消息队列
m0_59052131的博客
03-13 1613
消息队列的创建和读取相关注意事项和源代码及其执行结果。
Linux编程基础 5.2：消息队列
爱学习爱运动的专栏
05-05 2124
内容后面来补充
Linux网络编程之System V消息队列
Chenk的专栏
09-26 1453
System V消息队列函数： #include #include #include intmsgget(key_t key, int msgflg); intmsgctl(int msqid, int cmd, struct msqid_ds *buf); intmsgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg)
System V 消息队列（一）—— 消息队列相关接口函数（msgget / msgctl）
challenglistic的博客
12-06 1298
System V 消息队列（一）—— 消息队列相关接口函数（msgget / msgctl）
xml浅学笔记
05-15
1、必须增加响应消息头 header("Content-Tupe:application/xml"); 2、按照xml的语法结构，拼xml字符串，再响应给客户端 $xml="<?xml version='1.0' encoding='utf-8'?>"; $xml.="<...>"; ....
浅学二极管与三极管
06-24
### 浅学二极管与三极管 #### 一、二极管基础 ##### 1.1 PN结概述 二极管的核心是**PN结**。**PN结**是通过特殊的制造工艺，在同一块半导体材料（通常是硅或锗）上，通过扩散作用将**P型半导体**和**N型半导体**...
深度学习数据+配合博文“在git上面看到的代码，浅学了一下”
04-10
1. 这个是git上朋友发的，我这就是蹭蹭人家流量了 2. 是一个时序预测的问题的数据集 3. 每个小时一个数据，每个batch训练的数据是前一周也就是196个小时，预测的结果是下一天的数据24小时
消息队列接口封装
01-15
简单的linux下C消息队列的接口封装
提供http接口的消息队列
10-24
采用libevent，提供http接口的消息队列，http+redis实现的消息队列，支持多进程和多线程方式运行，并提供zmq外挂传输方式。
浅学RC充放电电路
06-24
### RC充放电电路知识点详解 #### 一、电容充放电原理 **1.1 电容充电** - **定义**: 当电容器接入电路并接通电源时，正极板上的自由电子通过电源向负极板移动，使得正极板失去负电荷而带正电，负极板获得负电荷而...
Linux进程通信——消息队列
嵌入式小白 记录学习过程
12-21 1260
Linux进程通信——消息队列接收，发送的分别实现及夫妻进程发送消息的综合实现。了解函数流程及key值使用
进程间通信之消息队列
flyingcloud6的博客
10-29 619
消息队列的原理，接口及代码测试
linux 消息队列
ckg3824278的博客
02-24 4715
管道：没有数据的类型，数据遵守“先进先出”的原则。 消息队列：加强型的管道，他可以指定存放的数据类型，与取走的数据类型,方便不同进程取数据。 消息队列，共享内存，信号量：属于system V(5) 版本的进程通信，也叫ipc通信对象，除了system V进程间的通信外，我们还有POSIX版本的。 查看system V (5)版本的通信对象命令： 查看消息队列： ipcs -q 查看共享内存： ...
消息队列（MQ）
ray2601992846的博客
03-11 435
今天我学习了以下有关MQ的一些知识，自己稍稍总结一下，也希望能给大家带来一点帮助 1.什么是MQ？ 在一个业务流程中所有处理请求先作为一个消息发送到MQ，接着处理消息的系统从MQ里获取消息并进行处理。一般来说，我们把发送消息的系统叫做消息生产者，接收处理消息的系统称作消息消费者，而根据消息处理的特点，可以得出两种消息模式： 1）点对点模式：生产者产生的每个消息，只能由一个消费者能消费。 2）发布订...
静态方法中使用jdbctemplate_JdbcTemplate浅学
06-13
可以在静态方法中使用JdbcTemplate，只需在方法中创建JdbcTemplate对象即可。以下是一个简单的示例： ```java import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.datasource.DriverManagerDataSource; public class MyDao { private static JdbcTemplate jdbcTemplate; static { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName("com.mysql.jdbc.Driver"); dataSource.setUrl("jdbc:mysql://localhost:3306/mydb"); dataSource.setUsername("username"); dataSource.setPassword("password"); jdbcTemplate = new JdbcTemplate(dataSource); } public static void myStaticMethod() { String sql = "SELECT COUNT(*) FROM mytable"; int count = jdbcTemplate.queryForObject(sql, Integer.class); System.out.println("Count: " + count); } } ``` 在上面的示例中，我们首先在静态块中创建了一个JdbcTemplate实例，然后在静态方法中使用该实例执行SQL查询。需要注意的是，我们在静态方法中不能直接访问非静态的实例变量或方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值