Linux消息队列

最新推荐文章于 2024-05-04 07:00:00 发布
最新推荐文章于 2024-05-04 07:00:00 发布
阅读量275 收藏
点赞数 1
分类专栏： LINUX 文章标签： linux 消息队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDNdesasdf/article/details/98469912
版权
  1. 消息队列
    链式队列
    在这里插入图片描述
    Msqid_ds 维护消息队列的结构体，队列的第一个消息指针msg_first，最后一个消息指针msg_last
    消息中有一个成员指针next

每一个消息中包含有哪些内容：
Data 数据
Length 数据的长度
Type 数据的类型。
例如：
1----voltage data
2----电流数据
3----有功功率
消息的接收端可以根据消息的类型来接收。
在这里插入图片描述
(1) msgget
在这里插入图片描述

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

int main()
{
        int msgid;


        msgid =msgget(IPC_PRIVATE, 0777);
        if(msgid <0)
        {
                printf("creat message queue failure\n");
                return -1;
        }
        printf("creat message queue sucess mid = %d\n",msgid);
        system("ipcs -q");
        //system("ipcrm -m shmid");
        return 0;
}

在这里插入图片描述
创建了消息队列
(2) msgsnd
在这里插入图片描述

msgctl(要删除的id号，要做说明操作，返回值)；

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

int main()
{
    int msgid;


    msgid =msgget(IPC_PRIVATE, 0777);
    if(msgid <0)
    {
            printf("creat message queue failure\n");
            return -1;
    }
    printf("creat message queue sucess mid = %d\n",msgid);
    system("ipcs -q");

    msgctl(msgid,IPC_RMID,NULL);
    system("ipcs -q");
    //system("ipcrm -m shmid");
    return 0;
}

在这里插入图片描述
删除队列消息

(2) msgsnd发送消息
在这里插入图片描述

#include<sys/types.h>
#include<sys/msg.h>
#include<signal.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//消息队列的数据类型
struct msgbuf
{
        long type;
        char voltage[124];
        char ID[14];
};
int main()
{
        int msgid;
        //定义消息的对象
        struct msgbuf sendbuf;


        msgid =msgget(IPC_PRIVATE, 0777);
        if(msgid <0)
        {
                printf("creat message queue failure\n");
                return -1;
        }
        printf("creat message queue sucess mid = %d\n",msgid);
        system("ipcs -q");
        //初始话消息
        sendbuf.type = 100;
        printf("please input message:\n");
        fgets(sendbuf.voltage,124,stdin);

        //开始写消息到消息队列
        msgsnd(msgid,(void *)&sendbuf,strlen(sendbuf.voltage),0);
        system("ipcs -q");
        while(1);
        msgctl(msgid,IPC_RMID,NULL);
        system("ipcs -q");
        //system("ipcrm -m shmid");
        return 0;
}

在这里插入图片描述

(3) msgrcv接收函数
在这里插入图片描述

#include<sys/types.h>
#include<sys/msg.h>
#include<signal.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//消息队列的数据类型
struct msgbuf
{
        long type;
        char voltage[124];
        char ID[14];
};
int main()
{
        int msgid;
        int readret;
        //定义消息的对象
        struct msgbuf sendbuf,recvbuf;


        msgid =msgget(IPC_PRIVATE, 0777);
        if(msgid <0)
        {
                printf("creat message queue failure\n");
                return -1;
        }
        printf("creat message queue sucess mid = %d\n",msgid);
        system("ipcs -q");
        //初始话消息
        sendbuf.type = 100;
        printf("please input message:\n");
        fgets(sendbuf.voltage,124,stdin);

        //开始写消息到消息队列
        msgsnd(msgid,(void *)&sendbuf,strlen(sendbuf.voltage),0);
        //开始读消息到消息队列里
        memset(recvbuf.voltage,0,124);
        readret = msgrcv(msgid,(void *)&recvbuf,124,100,0);
        printf("recv =%s",recvbuf.voltage);
        printf("readret = %d\n",readret);
        system("ipcs -q");
        while(1);
        msgctl(msgid,IPC_RMID,NULL);
        system("ipcs -q");
        //system("ipcrm -m shmid");
        return 0;
}

在这里插入图片描述
消息队列中数据读后，数据也不存在了，再次读取的时候数据没有了

msgsnd和msgrcv都可以设置为阻塞方式和非阻塞方式，阻塞方式设置为0

例子：通过消息队列，设置A和B之间的无亲缘之间的通信，可以相互通信，不单只是单向通信
写的程序（单向）

#include<sys/types.h>
#include<sys/msg.h>
#include<signal.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//消息队列的数据类型
struct msgbuf
{
        long type;
        char voltage[124];
        char ID[14];
};
int main()
{
        int msgid;
        int readret;
        int key;
        //定义消息的对象
        struct msgbuf sendbuf,recvbuf;
        key =ftok("./a.c",'a');
        if(key < 0)
        {
                printf("creat key failure\n");
                return -2;
        }
        printf("creat key sucess\n");

        msgid =msgget(key,IPC_CREAT | 0777);
        if(msgid <0)
        {
                printf("creat message queue failure\n");
                return -1;
        }
        printf("creat message queue sucess mid = %d\n",msgid);
        system("ipcs -q");
        sendbuf.type = 100;

        //写消息队列
        while(1)
        {
                //初始化缓存
                memset(sendbuf.voltage,0,124);
                //初始话消息
                //sendbuf.type = 100;
                printf("please input message:\n");
                fgets(sendbuf.voltage,124,stdin);

                //开始写消息到消息队列
                msgsnd(msgid,(void *)&sendbuf,strlen(sendbuf.voltage),0);
                //开始读消息到消息队列里
                memset(recvbuf.voltage,0,124);
        }
        system("ipcs -q");
        while(1);
        msgctl(msgid,IPC_RMID,NULL);
        system("ipcs -q");
        //system("ipcrm -m shmid");
        return 0;
}

读的函数（单向）

#include<sys/types.h>
#include<sys/msg.h>
#include<signal.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//消息队列的数据类型
struct msgbuf
{
        long type;
        char voltage[124];
        char ID[14];
};
int main()
{
        int msgid;
        int readret;
        int key;
        //定义消息的对象
        struct msgbuf sendbuf,recvbuf;
        key =ftok("./a.c",'a');
        if(key < 0)
        {
                printf("creat key failure\n");
                return -2;
        }
        printf("creat key sucess\n");

        msgid =msgget(key,IPC_CREAT | 0777);
        if(msgid <0)
        {
                printf("creat message queue failure\n");
                return -1;
        }
        printf("creat message queue sucess mid = %d\n",msgid);
        system("ipcs -q");
       
        //开始读消息队列
        while(1)
        {
                //初始化读缓存
                memset(recvbuf.voltage,0,124);
                //开始读消息队列内容
                msgrcv(msgid,(void *)&recvbuf,124,100,0);
                printf("receive data from message queue:%s",recvbuf.voltage);
        }
        msgctl(msgid,IPC_RMID,NULL);
        system("ipcs -q");
        //system("ipcrm -m shmid");
        return 0;
}

在这里插入图片描述
证明可以单向通信

通过父子进程实现双向通信
在这里插入图片描述
服务器端的实现

#include<sys/types.h>
#include<sys/msg.h>
#include<signal.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/ipc.h>
//消息队列的数据类型
struct msgbuf
{
        long type;
        char voltage[124];
        char ID[14];
};
int main()
{
        int msgid;
        int readret;
        int key;
        //定义消息的对象
        struct msgbuf sendbuf,recvbuf;
        int pid;
        key =ftok("./b.c",'a');
        if(key < 0)
        {
                printf("creat key failure\n");
                return -2;
        }
        printf("creat key sucess\n");

        msgid =msgget(key,IPC_CREAT | 0777);
        if(msgid <0)
        {
                printf("creat message queue failure\n");
                return -1;
        }
        printf("creat message queue sucess mid = %d\n",msgid);
        system("ipcs -q");
        pid = fork();
        if(pid > 0)//父进程写
        {

        sendbuf.type = 100;

        //写消息队列
        while(1)
        {
                //初始化缓存
                memset(sendbuf.voltage,0,124);
                //初始话消息
                //sendbuf.type = 100;
                printf("please input message:\n");
                fgets(sendbuf.voltage,124,stdin);

                //开始写消息到消息队列
                msgsnd(msgid,(void *)&sendbuf,strlen(sendbuf.voltage),0);
                //开始读消息到消息队列里
                memset(recvbuf.voltage,0,124);
        }
        }
        if(pid  == 0)//子进程读
        {
                while(1)
                {
                memset(recvbuf.voltage,0,124);
                msgrcv(msgid,(void *)&recvbuf,124,200,0);//从哪里读，读到哪里去，读多少个，读什么样的数据类型，以什么方式读（0为阻塞）
                printf("receive message from message queue:%s\n",recvbuf.voltage);
                }
        }

        system("ipcs -q");
        while(1);
        msgctl(msgid,IPC_RMID,NULL);
        system("ipcs -q");
        //system("ipcrm -m shmid");
        return 0;
}

客户端的实现

#include<sys/types.h>
#include<sys/msg.h>
#include<signal.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/ipc.h>
//消息队列的数据类型
struct msgbuf
{
        long type;
        char voltage[124];
        char ID[14];
};
int main()
{
        int msgid;
        int readret;
        int key;
        //定义消息的对象
        struct msgbuf sendbuf,recvbuf;
        int pid;
        key =ftok("./b.c",'a');
        if(key < 0)
        {
                printf("creat key failure\n");
                return -2;
        }
        printf("creat key sucess\n");

        msgid =msgget(key,IPC_CREAT | 0777);
        if(msgid <0)
        {
                printf("creat message queue failure\n");
                return -1;
        }
        printf("creat message queue sucess mid = %d\n",msgid);
        system("ipcs -q");
        pid = fork();
        if(pid ==  0)//子进程写
        {

        sendbuf.type = 200;

        //写消息队列
        while(1)
        {
                //初始化缓存
                memset(sendbuf.voltage,0,124);
                //初始话消息
                //sendbuf.type = 100;
                printf("please input message:\n");
                fgets(sendbuf.voltage,124,stdin);

                //开始写消息到消息队列
                msgsnd(msgid,(void *)&sendbuf,strlen(sendbuf.voltage),0);
                //开始读消息到消息队列里
                memset(recvbuf.voltage,0,124);
        }
        }
        if(pid > 0)//父进程读
        {
                while(1)
                {
                memset(recvbuf.voltage,0,124);
                msgrcv(msgid,(void *)&recvbuf,124,100,0);//从哪里读，读到哪里去，读多少个，读什么样的数据类型，以什么方式读（0为阻塞）
                printf("receive message from message queue:%s\n",recvbuf.voltage);
                }
        }
        system("ipcs -q");
        while(1);
        msgctl(msgid,IPC_RMID,NULL);
        system("ipcs -q");
        //system("ipcrm -m shmid");
        return 0;
}

在这里插入图片描述
通过对队列消息的操作，对同一个文件b.c的读写利用fork产生的key属性，客户端和服务端都对key操作，父子进程交叉进程读写

believe_oneself_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LINUX进阶（系统篇）之消息队列msgrcv（）和msgsnd()详解
心跳包的博客
11-01 2465
目录 1.msgsnd()函数原型 1.1 函数说明 1.2 参数说明 1.3 返回值说明 1.4 所需头文件 1.5 发送函数例程 2.msgrcv()函数原型 2.1 函数说明 2.2 参数说明 2.3 返回值说明 2.4 头文件 2.5 接收函数例程 3.运行测试 1.msgsnd()函数原型 int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg) 1.1 函数说明 msgsnd的作..
Receive queue 和 Send queue 理解说明
weixin_33816946的博客
01-06 351
1、关于netstat -anq 的Recv-Q与Send-Q说明[root@zayhu01-mb ~]# netstat -anp | headActive Internet connections (servers and established)Proto Recv-Q Send-Q Local Address Foreign Addres...
linux进程通信之消息队列
梦的灰色边沿...
09-03 1193
文章目录1 消息队列2 信号3 示例程序3.1 创建和销毁消息队列3.2 单服务器单客户端同步通信3.3 消息队列简单的信号通知3.4 异步安全的消息队列信号通知3.5 通过管道实现异步安全3.6 新开线程实现数据读取3.7 实时信号示例   消息队列是一种进程间通信或同一进程的不同线程间的通信方式，软件的贮列用来处理一系列的输入，通常是来自用户。消息队列提供了异步的通信协议，每一个贮列中的纪录包含详细说明的数据，包含发生的时间，输入设备的种类，以及特定的输入参数，也就是说：消息的发送者和接收者不需要同时与
Linux POSIX消息队列遇到的问题和使用方法
最新发布
weixin_46158019的博客
05-04 1134
开发板：nuc9801.ARM Linux中消息队列的原理在ARM Linux中，消息队列是通过POSIX（Portable Operating System Interface）标准实现的。消息队列在内核中维护，通过文件系统（如/dev/mqueue）或系统调用来访问。消息队列具有以下几个主要特点异步通信：发送进程和接收进程不需要同时处于活动状态。发送进程可以将消息放入队列，然后继续进行其他操作；接收进程可以在需要时从队列中取出消息。消息独立性：队列中的每个消息都是独立的，拥有自己的属性和内容。顺序性。
TCP/IP(1)——TCP 三次握手、backlog参数、Recv-Q和Send-Q
静水流深且细水长流
07-06 1122
TCP 的三次握手 client发送SYN到server，将状态修改为SYN_SEND，如果server收到请求，则将状态修改为SYN_RCVD，并把该请求放到syns queue队列中。 server回复SYN+ACK给client，如果client收到请求，则将状态修改为ESTABLISHED（半连接?），并发送ACK给server。 server收到ACK，将状态修改为ESTABLISH...
「TCP」Recv-Q和Send-Q
完颜振江
01-17 4383
1 LISTEN状态：表示队列中的连接数量，非LISTEN状态为字节数量； 非 LISTEN 状态 Recv-Q 表示 receive queue 中的 bytes 数量； Send-Q 表示 send queue 中的 bytes 数值。 2 Recv-Q 正在等待accept的连接数，Send-Q表示全连接队列容量 表示的当前等待服务端调用 accept 来三次握手的 listen backlog 数值，即图中的全连接队列值（最大值为Send_Q+1），当客户端通过connect() 去连接正
linux消息队列
07-29
Linux 消息队列 Linux 消息队列是一种进程间通信（IPC）机制，允许不同的进程之间进行通信和数据交换。在 Linux 系统中，消息队列是通过 System V IPC 机制实现的。消息队列可以用于实现进程之间的通信、数据交换和...
linux消息队列源码
03-27
Linux消息队列是一种进程间通信（IPC）机制，允许不同进程之间传递数据。它不同于管道、套接字或共享内存，因为消息队列提供了异步通信的可能性，即发送方不必等待接收方立即处理消息。在Linux内核中，消息队列作为...
linux消息队列测试
08-28
Linux消息队列是一种高效、可靠且灵活的进程间通信（IPC）机制，允许不同进程之间交换数据。在标题“linux消息队列测试”中，我们可以理解这是一个针对Linux系统中的消息队列功能进行验证和性能测试的程序。描述指出...
msg.zip_LINUX消息队列_linux 消息队列
09-22
在Linux操作系统中，消息队列是一种非常重要的进程间通信（IPC，Inter-Process Communication）机制。消息队列允许一个进程发送消息给另一个进程，并且这些消息会被存储在一个内核管理的数据结构中，直到接收进程...
发送数据包
weixin_33722405的博客
03-18 306
提起发送数据包大家可能会想到使用SOCKET编程来实现，但其实WinPcap也提供了发送数据包的API，尽管从名字上来看它应该是用来数据捕捉的。值得注意的是，libpcap不支持发送数据包的功能，因此下面提到的函数都是WinPcap的扩展，在UNIX平台下是不支持的。下面这个实例程序正是利用了WinPcap中的pcap_sendpacket()来发送单个数据包。 #include...
Linux进程通信之消息队列
m0_60010936的博客
11-27 4051
Linux 消息队列
【Linux】进程间通信之消息队列
一点一点变好
06-16 2117
【Linux】进程间通信之消息队列
Linux--消息队列
m0_59052131的博客
03-13 1612
消息队列的创建和读取相关注意事项和源代码及其执行结果。
[Linux]-进程间通信之消息队列
levi的博客
06-22 2601
之前我们使用过的管道比较适用于较少进程之间的通信，那么如果想要实现多个进程之前的通信的话，我们需要使用消息队列消息队列具有如下特点1.消息队列是消息的链表，存放于内存中，内核维护消息队列2.消息队列中的消息是有类型的3.消息队列中的消息是有格式的4.消息队列可实现消息随机查询，并且不一定要遵循先进先出的顺序，而是每个进程可以按照感兴趣的类型进行读取5.与管道相同，读出数据后，消息队列对应数据会被删除6.每个管道都有消息队列标识符，在整个系统中是唯一的7.消息队列允许。
Linux进程间通信——消息队列
m0_53267045的博客
11-02 1774
1. 消息队列可以实现消息的随机查询，满足队列的特点但不一定要以先进先出的次序读取，可以按消息的类型读取；System V提供的IPC通信机制需要一个key值，通过key 值就可在系统内获得一个唯一的消息队列。5. 只有内核重启或人工删除时，该消息才会被删除，若不人工删除消息队列，消息队列会一直存在于内存中。3.与无名管道、有名管道一样，从消息队列中读出消息，消息队列中数据会被删除;4.消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级；2.消息队列允许一个或多个进程向它写入或者读取消息；
linux 消息队列
10-20
Linux消息队列是一种进程间通信机制，它允许一个或多个进程向队列中添加消息，同时另一个或多个进程从队列中读取消息。Linux消息队列是一种可靠的、异步的、面向记录的进程间通信机制，它可以在不同的进程之间传递...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值