进程间通信方式（二）：System V 消息队列

已于 2025-05-22 00:38:35 修改
阅读量603 收藏 4
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 系统编程 文章标签： 消息队列 System V 进程间通信 msqid_ds ipc_perm
于 2019-09-06 11:40:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/X_Perseverance/article/details/100527982
本文深入解析SystemV消息队列，涵盖概念、特点、数据结构及内核表示，详细讲解msgget、msgctl、msgsnd、msgrcv等核心函数，并提供综合应用实例，帮助读者掌握消息队列的使用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、概念

  消息队列又叫做报文队列，是一条由消息连接而成的链式队列，它保存在内核中，并使用消息队列标识符进行标识。
  消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法，并且每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据块。对消息队列有写权限的进程可以向消息队列中按照一定的规则添加新消息，对消息队列有读权限的进程则可以从消息队列中读走消息。
  目前主要有两种类型的消息队列：System V 消息队列 和 POSIX 消息队列，本文仅对前者展开讲述。

二、特点

  1. 消息队列中的每一个消息都具有特定的格式以及特定的优先级；

  2. 消息队列在内核中使用特定的标识符进行标识，从而保证了消息队列在整个系统中的唯一性，所以可以通过标识符来访问消息队列；

  3. 消息队列具有一定的 FIFO（先入先出）特性，但是它也可以实现消息的随机查询，比 FIFO 具有更大的优势；

  4. System V 消息队列是随内核持续的，只有在内核重启或者显式删除一个消息队列时，该消息队列才会被真正删除；

  5. 在 Linux 中，消息队列有如下限制：

    （1）MSGMNI：系统中允许存在的消息队列的最大数量
    （2）MSGMAX：单个消息的最大字节数
    （3）MSGMNB：单个消息队列的最大总字节容量（所有消息的总和）

    查看方法如下：
    方法一：通过 ipcs -lq 命令查看

    在这里插入图片描述
    方法二：查看系统内核信息

    在这里插入图片描述

三、IPC 对象数据结构

  内核为每个 IPC 对象维护一个数据结构，该结构说明了 IPC 对象的权限和所有者，详细信息可参阅文件 /usr/include/linux/ipc.h 。

struct ipc_perm {
	__kernel_key_t  key;   /* Key supplied to ***get(2) */
	__kernel_uid_t  uid;   /* Effective UID of owner */
	__kernel_gid_t  gid;   /* Effective GID of owner */
	__kernel_uid_t  cuid;  /* Effective UID of creator */
	__kernel_gid_t  cgid;  /* Effective GID of creator */
	__kernel_mode_t mode;  /* Permissions  */
	unsigned short  seq;   /* Sequence number */
};

  结构中的 mode 类似于创建文件时使用的 mode，但是没有执行权限，具体取值如下：

操作者只读权限只写权限可读可写权限
所有者 (owner)040002000600
用户组 (group)004000200060
其他 (others)000400020006

  当调用 IPC 对象的创建函数（msgget、semget、shmget ）时，会对 ipc_perm 结构体中的每一项赋值，在后续的操作中若要修改这几项则调用相应的控制函数（msgctl、semctl、shmctl），需要注意的是，只有超级用户或者创建 IPC 对象的进程才有权改变 ipc_perm 结构的值。

四、消息队列数据结构

  在内核中，每个消息队列都有一个 msqid_ds 结构与其关联，该结构描述了消息队列的一些属性和状态信息等，详细信息可参阅文件 /usr/include/linux/msg.h 。

struct msqid_ds {
	struct ipc_perm msg_perm;	/* Ownership and permissions */
	struct msg *msg_first;		/* first message on queue,unused  */
	struct msg *msg_last;		/* last message in queue,unused */
	__kernel_time_t msg_stime;	/* last msgsnd time */
	__kernel_time_t msg_rtime;	/* last msgrcv time */
	__kernel_time_t msg_ctime;	/* last change time */
	unsigned long  msg_lcbytes;	/* Reuse junk fields for 32 bit */
	unsigned long  msg_lqbytes;	/* ditto */
	unsigned short msg_cbytes;	/* current number of bytes on queue */
	unsigned short msg_qnum;	/* number of messages in queue */
	unsigned short msg_qbytes;	/* max number of bytes on queue */
	__kernel_ipc_pid_t msg_lspid;	/* pid of last msgsnd */
	__kernel_ipc_pid_t msg_lrpid;	/* last receive pid */
};

五、消息队列在内核中的表示

  在前面，我们说过消息队列是一条由消息连接而成的链式队列，所以也可以说每一个消息都是队列中的一个节点，而每个节点的结构类似于下面这样：

struct msg {
    Type msg_type;
    Length msg_len;
    Data msg_data;
    struct msg *next;
}

  假设现在有一个含有三个消息的消息队列，这些消息的类型分别为 10、20 和 30，长度分别为1字节、2字节和3字节，那么该消息队列在内核中将以如下图所示的结构来表示。
在这里插入图片描述
  从上图来看，系统中的每一个消息队列都有一个唯一的标识符，并且都由一个 msqid_ds 结构来表示，其中 msqid_ds.msg_first 和 msqid_ds.msg_last 分别指向这个链式队列的头部和尾部。
  当发送一个消息到该消息队列时，先把发送的消息构造成一个 msg 结构对象，然后再将该对象添加到由 msqid_ds.msg_first 和 msqid_ds.msg_last 维护的队列中去；而当从消息队列中接收一个消息时，先根据消息的类型 msg_type 有选择地从队列中遵照 FIFO 原则读取特定类型的消息，再将该消息从队列中删除并修改 msqid_ds 结构对象的数据。

六、消息队列相关函数

1. msgget

  • 【头文件】：#include <sys/types.h>、#include <sys/ipc.h>、#include <sys/msg.h>
  • 【函数原型】：int msgget(key_t key, int msgflg);
  • 【功能】：创建或打开一个消息队列，这里创建的消息队列数量会受到系统消息队列数量的限制
  • 【参数】：

（1）key：消息队列的键值，其中有一个特殊值 IPC_PRIVATE，它用于创建当前进程的私有消息队列
（2）msgflg：权限标志位，由两部分组成，一部分为IPC对象存取权限（含义同 ipc_perm 中的 mode），另一部分为IPC对象创建模式标志（IPC_CREAT、IPC_EXCL），一般会将这两部分进行 | 运算，从而完成对IPC对象创建的管理

  • 【返回值】：成功返回一个消息队列标识符（非负整数）；失败则返回 -1，并将 errno 设置为错误标识符

在这里插入图片描述

创建或打开一个 IPC 对象的逻辑流程图

【示例】：演示 IPC_CREAT|IPC_EXCL 的使用效果
【代码】：

#include <stdio.h>    
#include <sys/types.h>    
#include <sys/ipc.h>    
#include <sys/msg.h>    
#include <errno.h>    
    
int main() {    
    extern int errno;    
    
    int msqid = msgget(0x123, IPC_CREAT|IPC_EXCL|0644);                               
    if(msqid == -1) {    
        perror("msgget");    
        printf("errno: %d\n", errno);    
        return -1;    
    }    
    
    printf("msqid: %d\n", msqid);    
    
    return 0;    
}

【执行结果】：

在这里插入图片描述
【分析】：
  从执行结果来看，当我们第一次运行程序时，成功创建了消息队列。但是，当第二次运行程序后，发现创建失败，errno 被置为17，也就是 EEXIST，错误信息为 File exists，出现这样的结果是因为我们在第一次程序运行后，该消息队列就已经在系统中存在了，而我们在创建消息队列又使用了 IPC_EXCL，这才导致 msgget 出错返回。

2. msgctl

  • 【头文件】：#include <sys/types.h>、#include <sys/ipc.h>、#include <sys/msg.h>
  • 【函数原型】：int msgctl(int msqid, int cmd, struct msqid_ds *buf);
  • 【功能】：获取或设置消息队列的有关信息
  • 【参数】：

（1）msqid：消息队列标识符
（2）cmd：对消息队列要采取的动作

取值说明
IPC_STAT读取消息队列的 msqid_ds 结构信息，并将其存储在 buf 指定的地址空间中
IPC_SET设置消息队列的 msqid_ds 结构信息，这些取值来自于 buf 指定地址空间中的参数（需要足够权限）
IPC_RMID将消息队列从内核中删除

（3）buf：描述消息队列 msqid_ds 数据结构的变量

  • 【返回值】：成功返回 0；失败则返回 -1，并将errno设置为错误标识符

【示例】：演示 IPC_STAT 的使用效果
【代码】：

#include <stdio.h>    
#include <sys/types.h>    
#include <sys/ipc.h>    
#include <sys/msg.h>    
    
int main() {
    int msqid = msgget(0x123, IPC_CREAT|0644);
    if(msqid == -1) {
        perror("msgget");
        return -1;
    }
    printf("msqid: %d\n", msqid);

    struct msqid_ds buf;
    if(msgctl(msqid, IPC_STAT, &buf) == -1) {
        perror("msgctl");
        return -1;
    }

    printf("key: %#x\n", buf.msg_perm.__key);
    printf("mode: %#o\n", buf.msg_perm.mode);
    
    return 0;
}

【执行结果】：

在这里插入图片描述

3. msgsnd

  • 【头文件】：#include <sys/types.h>、#include <sys/ipc.h>、#include <sys/msg.h>
  • 【函数原型】：int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
  • 【功能】：将指定消息添加到已打开消息队列的队尾
  • 【参数】：

（1）msqid：消息队列标识符
（2）msgp：消息结构指针，指向准备发送的消息

消息结构如下：

struct msgbuf {    
    long mtype; //type of message，必须大于0，msgrcv 将利用这个长整数确定消息的类型
    char mtext[1]; //message text，可以设定为更多的字节数但必须小于 MSGMAX
};

（3）msgsz：msgp 所指向消息的正文长度，这个长度不包含保存消息类型的那个 long int 型整数
（4）msgflg：控制着当前消息队列满或到达系统上限时将要发生的事情

取值说明
IPC_NOWAIT若消息无法立即发送（比如当前队列已满），那么函数会立即返回，并把 errno 置为 EAGAIN
0函数进入阻塞状态，直到发送成功为止
  • 【返回值】：成功返回 0；失败则返回 -1，并将errno设置为错误标识符

4. msgrcv

  • 【头文件】：#include <sys/types.h>、#include <sys/ipc.h>、#include <sys/msg.h>
  • 【函数原型】：ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
  • 【功能】：从消息队列中取走一条消息，与 FIFO 不同的是，这里可以取走指定类型的消息
  • 【参数】：

（1）msqid：消息队列标识符
（2）msgp：消息结构指针，指向消息接收缓冲区
（3）msgsz：msgp 所指向消息的正文长度，这个长度不包含保存消息类型的那个 long int 型整数
（4）msgtyp：指定接收消息的类型

取值说明
msgtyp>0返回消息队列中第一条类型为 msgtyp 的消息
msgtyp=0返回消息队列中的第一条消息
msgtyp<0返回消息队列中一条类型小于或等于 msgtyp 绝对值的消息，并且在满足条件的所有消息中其又是类型最小的消息

（5）msgflg：控制着队列中没有相应类型的消息可供接收时将要发生的事

取值说明
MSG_NOERROR若返回的消息大小超过 msgsz，那么消息就会截短到 msgsz 字节，并且不会报错
IPC_NOWAIT若在消息队列中没有相应类型的消息可以接受，那么函数会立即返回，并把 error 置为 ENOMSG
0函数进入阻塞状态，直到接收到一条相应类型的消息为止
  • 【返回值】：成功返回实际放到接收缓冲区中的字节数；失败则返回 -1，并将errno设置为错误标识符

七、综合应用

【示例】：利用消息队列实现服务端与客户端通信
【代码】：

/*
 * 服务端：server.c
 */
 
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>

#define PATHNAME "."
#define PROJ_ID 123

#define SERVER_TYPE 1
#define CLIENT_TYPE 2

int main() {
    //生成IPC键值
    key_t key = ftok(PATHNAME, PROJ_ID);
    if(key == -1) {
        perror("ftok");
        return -1;
    }

    //创建并打开消息队列
    int msqid = msgget(key, IPC_CREAT|IPC_EXCL|0644);
    if(msqid == -1) {
        perror("msgget");    
        return -1;    
    }    
    
    //利用消息队列通信    
    int count = 3; //通信次数    
    while(count--) {    
        struct {    
            long mtype;    
            char mtext[32];               
        } sndmsg, rcvmsg;                   
                                                                                      
        //从消息队列中读取客户端消息    
        printf("# Please wait ...\n");    
        if(msgrcv(msqid, &rcvmsg, sizeof(rcvmsg.mtext), CLIENT_TYPE, 0) == -1) {
            perror("msgrcv");
           	return -1;
        }
        printf("> Client: %s", rcvmsg.mtext);

        //向消息队列中添加服务端消息
        printf("# Please input: ");
        fflush(stdout);
        char text[32] = {0};
        if(read(0, text, sizeof(text)) == -1) {
            perror("read");
            return -1;
        }
        sndmsg.mtype = SERVER_TYPE;
        strcpy(sndmsg.mtext, text);
        if(msgsnd(msqid, &sndmsg, sizeof(sndmsg.mtext), 0) == -1) {
            perror("msgsnd");
            return -1;
        }
    }

    return 0;
}

/*
 * 客户端：client.c
 */

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

#define PATHNAME "."
#define PROJ_ID 123

#define SERVER_TYPE 1
#define CLIENT_TYPE 2

int main() {
    //生成IPC键值
    key_t key = ftok(PATHNAME, PROJ_ID);
    if(key == -1) {
        perror("ftok");
        return -1;
    }

    //打开消息队列
    int msqid = msgget(key, 0);
    if(msqid == -1) {
        perror("msgget");
        return -1;
    }

    //利用消息队列通信
    int count = 3; //通信次数
    while(count--) {    
        struct {    
            long mtype;    
            char mtext[32];    
        } sndmsg, rcvmsg;    
                                                                                      
        //向消息队列中添加客户端消息    
        printf("# Please input: ");    
        fflush(stdout);    
        char text[32] = {0};
        if(read(0, text, sizeof(text)) == -1) {    
            perror("read");
            break;
        }
        sndmsg.mtype = CLIENT_TYPE;
        strcpy(sndmsg.mtext, text);
        if(msgsnd(msqid, &sndmsg, sizeof(sndmsg.mtext), 0) == -1) {
            perror("msgsnd");
            break;
        }

        //从消息队列中读取服务端消息
        printf("# Please wait ...\n");
        if(msgrcv(msqid, &rcvmsg, sizeof(rcvmsg.mtext), SERVER_TYPE, 0) == -1) {
            perror("msgrcv");
            break;                      
        }
        printf("> Server: %s", rcvmsg.mtext);
    }

    //删除消息队列
    if(msgctl(msqid, IPC_RMID, NULL) == -1) {
        perror("msgctl");
        return -1;
    }

    return 0;
}

【执行结果】：

在这里插入图片描述




【知识点扩展】：

IPC之三：使用 System V 消息队列进行进程间通信的实例
whowin
08-08 590
IPC 是 Linux 编程中一个重要的概念，IPC 有多种方式，本文主要介绍消息队列(Message Queues)，消息队列可以完成同一台计算机上的进程之间的通信，相比较管道，消息队列要复杂一些，但使用起来更加灵活和方便，本文针对 System V 消息队列，并给出了多个具体的实例，每个实例均附有完整的源代码；本文所有实例在 Ubuntu 20.04 上编译测试通过，gcc版本号为：9.4.0；本文适合 Linux 编程的初学者阅读。
进程间通信(7) - 消息队列(System V)
06-18 1957
进程间通信(7) - 消息队列(System V)
进程间通讯方式
四年
10-30 819
进程间通信IPC------Inter-Process Communication 由于内存管理的一些机制，导致两个进程间并不能直接的进行通信(在独立的用户空间),因此我们需要利用一些介质来完成两个进程之间的通信。以下是常用的进程间通信方式。 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。 有名管道
System v 和Posix
xuaomo的博客
08-19 715
System v 和Posix当我们在linux系统中进行进程间通信时，会发现例如共享内存，信号量，消息队列等方式时，会发现有System v以及POXIS两种类型。因此，我们探究一下System v和POXIS到底代表着什么意义。POSIXPOSIX(Portable Operating System Interface for Computing Systems)是由IEEE 和ISO/IEC
system V 进程间通信-------消息队列
baidu_37964044的博客
08-11 215
进程间通信，顾名思义就是进程和进程通信，也就是进程a和进程b可以访问内核的同一块空间一个放数据，一个取数据，那么这两个进程就完成通信通信了。 消息队列也有管道一样的不足：1.每个消息的最大长度是有上限的MSGMAX字节，每个消息队列的总字节数是有上限的MSGMNB，系统中消息队列的总数是有上限的MSGMNI 如何查看： cat   /proc/sys/kernel/msgmax cat  ...
Linux的进程间通信-消息队列
凌风探梅的专栏
09-20 1625
Linux的进程间通信-消息队列 微博ID：orroz 微信公众号：Linux系统技术 前言 Linux系统给我们提供了一种可以发送格式化数据流的通信手段，这就是消息队列。使用消息队列无疑在某些场景的应用下可以大大减少工作量，相同的工作如果使用共享内存，除了需要自己手工构造一个可能不够高效的队列外，我们还要自己处理竞争条件和临界区代码。而内核给我们提供的消息队列
消息队列（定义、结构、如何创建、消息队列的发送与接收、发送与接收实例）
热门推荐
scarificed的博客
11-22 4万+
一、定义 1、消息队列是一种先进先出的队列型数据结构，实际上是系统内核中的一个内部链表。消息被顺序插入队列中，其中发送进程将消息添加到队列末尾，接受进程从队列头读取消息。 2、多个进程可同时向一个消息队列发送消息，也可以同时从一个消息队列中接收消息。发送进程把消息发送到队列尾部，接受进程从消息队列头部读取消息，消息一旦被读出就从队列中删除。 二、结构 1、消息队列中消息本身由消息类型和消息数据组成，通常使用如下结构： struct msgbuf { long mtype; char mtext[
进程通信(4):System V消息队列
_
07-17 176
内核中的System V消息队列。
Linux进程间通信：System V消息队列实现与应用
在Linux系统中，进程间通信是通过多种方式实现的，其中System V消息队列就是一种历史悠久的IPC机制。 描述中提到的“博客http://blog.youkuaiyun.com/shallnet 文章对应源码下载”，意味着该压缩包是与某篇博客文章相关联...
操作系统Linux消息队列详解：进程间通信的关键技术与应用实例
最新发布
04-12
内容概要：本文详细介绍了Linux消息队列作为进程间通信（IPC）的重要方式。消息队列是一种位于内核空间的链表结构，用于传递结构化数据，具有独立性、消息封装、顺序性、消息标识等特点。文中解释了消息队列的工作...
SystemV消息队列：Linux进程间的高级通信方式
它的历史可以追溯到上世纪70年代末期，由贝尔实验室的一个分支机构开发，随后在System V系统中集成，并被广泛应用于商业UNIX系统中，提供了丰富的进程间通信功能。 与POSIX消息队列相比，SystemV消息队列的主要区别...
【Linux系统编程】第三十七弹---深入理解System V IPC机制：消息队列、信号量与共享内存的实战解析
小林熬夜学习编程的博客
10-25 1270
system V 消息队列：什么是System V消息队列，基本原理；system V信号量：基本概念，主要操作，相关函数；共享内存，消息队列，信号量~~~
System V 消息队列（一）—— 消息队列相关接口函数（msgget / msgctl）
challenglistic的博客
12-06 1488
System V 消息队列（一）—— 消息队列相关接口函数（msgget / msgctl）
Android Handler消息队列的实现原理
变
08-16 4226
我们在写Android程序的时候，有经常用到Handler来与子线程通信，亦或者是用其来管理程序运行的状态时序。Handler其是由Android提供的一套完善的操作消息队列的API。它既可以运行在主线程中，也可以运行在子线程中，唯一的区别是其内部的Looper对象不同。在这里我将对Android中Handler消息队列的实现进行一个总结，以便深入了解其原理并且巩固其使用方式。 本系列的主要内容如...
数据结构之消息队列
浅青雨
02-21 1950
一、数据结构： 1 、数据的集合 2、数据之间的关系 二、队列有两种方式：一种是普通队列，一种是环形队列； 三、队列创建步骤：创建队列，销毁队列，清空队列，判空队列，队列长度，新元素入队，首元素出队，遍历队列； 四、队列特点：先进先出（First In First Out - FIFO） 五、普通队列的两个缺点：队列中n个元素出队后，剩余元素的指针都需前移n，操作复杂；如果指针不
消息队列数据结构
weixin_30790841的博客
10-16 529
MattPietrek 著“Windows 95 System Programming SECRETS”第三章 转载于:https://www.cnblogs.com/azbane/p/7675622.html
关于System V 消息队列介绍
博客
07-26 1410
关于SystemV消息队列 操作函数： int msgctl(int msqid, int cmd, struct msqid_ds*buf);操作选项:     IPC_RMID  从系统中删除mqisd指定的消息队列.仍在队列上的消息都丢弃     IPC_SET   给所指定的消息队列设置其mqsid_ds结构的几个成员: uid, gid, mode,msq_qbytes    
Linux 17 IPC之消息队列msg
分享各种网络协议知识
06-17 219
消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法。 每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据结构。 函数定义如下： #include <sys/msg.h> int msgctl(int msqid, int cmd, struct msqid_ds *buf); int msgget(key_t key, int msgflg); int...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值