linux C -- 消息队列

已于 2024-04-17 11:01:24 修改
阅读量797 收藏 9
点赞数 21
文章标签： linux c语言
于 2024-04-16 23:59:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lastliudexi/article/details/137845048
版权

linux C -- 消息队列

前言

进程间通信是linux下经常用到的通信方式，可用于多个进程之间的通信，也可在一个进程内通信。
消息队列就是一堆消息的有序集合（队列），并缓存于内核中。如此一来，多个进程就可通过访问内核来实现多个进程之间的通信。目前存在的消息队列有POSIX（mq）与System V（IPC）标准接口。

一、System V(IPC)消息队列

接口说明
消息缓冲区的结构定义一般如下：

struct msg_form {
    long mtype;//类型
    char mtext[];//消息内容，可以是定长数组或者变长数组
};

头文件：

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

接口调用主要涉及到 msgget、msgsnd、msgrcv 和 msgctl 四个接口：

1、创建消息队列 msgget

/**
函数：创建或获取消息队列 
入参：key：key可取由ftok创建的key值或1个整数；
	 msgflag主要有两个值IPC_CREAT 和IPC_EXC，指的是需要新创建消息队列ID，低位可用来确定消息队列的访问权限。例如（IPC_CREAT | 0777）
返回：成功返回消息队列id，失败返回-1
**/
int msgget(key_t key, int msgflg)

2、发送消息到队列

/**
函数：发送消息到队列
入参：msqid：消息队列的ID（由msgget生成的消息队列标识符）
	 msgp：msgq为指向的用户定义缓冲区，一般定义为结构体，首个成员为long型，表示消息的类型，另外一个一般为char mtext[];
	 msgsz：发送消息正文的字节数，注意这里的是指正文内容mtext里面数据的字节数
	 msgflg：标志位，IPC_NOWAIT消息没有发送完成函数也会立即返回，0 直到发送完成函数才返回
返回：成功返回0，错误返回-1
**/
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg)

3、从队列接收信息

/**
函数：发送消息到队列
入参：msqid：消息队列的ID（由msgget生成的消息队列标识符）
	 msgp：读取到的数据要放到哪里，这里填我们自定义的结构体对象
	 msgsz：要读取的正文字节数，是指正文内容mtext里面数据的字节数
	 msgtyp：要读取的消息类型，mtype（默认用0）
	 msgflg：标志位，IPC_NOWAIT非堵塞等待，0 堵塞等待   
返回：成功返回读取到的字节数，失败就返回-1，错误码被设置
**/
int msgrcv(int msgid, void * msgq, size_t msgsz, long int msgtyp, int msgflg)

进阶说明

/** 
msgtyp：
    =0 直接返回第一条消息（FIFO原理）
    >0 若msgflg不包含MSG_EXCEPT，则返回消息队列中第一个类型为msgtpy，
       若包含，则返回消息队列第一个类型为msgtpy
    <0 返回消息队列中类型≤msgtpy绝对值的消息，若多个，取最小

msgflg： 
    不包含MSG_NOERROR，消息又太长，则不对该消息做任何处理直接返回-1
    包含MSG_NOERROR，则该消息被截取msgsz字节返回，剩余部分被丢弃
*/

4、控制消息队列 msgctl

/**
函数：发送消息到队列
入参：msqid：消息队列的ID（由msgget生成的消息队列标识符）
	 cmd：IPC_STAT 将msg相关的内核信息存储到buf指向的msqid_ds 结构体中。
    	  IPC_SET 该命令用来设置消息队列的属性，要设置的属性存储在buf指向的msqid结构中；
	 	  IPC_RMID 删除msqid标识的消息队列
	 buf：在标志位中设置了IPC_STAT，指针所指向的变量里面就能拿到相关的内核信息，
          如果不关心内核信息可以设置为nullptr
返回：成功返回0，错误返回-1
**/
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

msqid_ds 这个结构体是比较复杂的，需要进阶的朋友可以自行了解

struct msqid_ds {
    struct ipc_perm msg_perm{   // 消息队列的权限信息
        key_t key;          	// 消息队列的键值
        uid_t uid;          	// 拥有者的用户ID
        gid_t gid;          	// 拥有者的组ID
        uid_t cuid;         	// 创建者的用户ID
        gid_t cgid;         	// 创建者的组ID
        mode_t mode;        	// 权限
        unsigned short seq; 	// 序列号
    }
    time_t msg_stime;            // 上次发送消息的时间
    time_t msg_rtime;            // 上次接收消息的时间
    time_t msg_ctime;            // 上次变更时间
    unsigned long msg_cbytes;    // 消息队列中的字节数
    msgqnum_t msg_qnum;          // 消息队列中的消息数量
    msglen_t msg_qbytes;         // 消息队列的最大字节数
    pid_t msg_lspid;             // 最后发送消息的进程ID
    pid_t msg_lrpid;             // 最后接收消息的进程ID
};

5、删除消息队列

IPC_RMID
立即删除消息队列，此时所有阻塞在对该消息队列的，msgsnd和msgrcv函数调用，
都会立即返回失败，errno为EIDRM

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

二、代码编写

1、发送部分的代码

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

int main (void) {
	printf("创建消息队列...\n");
	key_t key = ftok(".",100);
	if(key == -1){
		perror("ftok");
		return -1;
	}
	
	int msgid = msgget(key,IPC_CREAT | 0777);
	if(msgid == -1){
		perror("msggeet");
		return -1;
	}
	
	printf("从消息队列（0x%08x/%d)中发送消息...\n",key,msgid);
	
	
	for(;;){
		struct {
			long mtype;
			char mtext[1024];
		}msgbuf;
		
		printf(">");
        gets(msgbuf.mtext);
        msgbuf.mtype = 1; //传输的消息类型是>0的整数
		
		
		ssize_t msgsz = msgsnd(msgid,(void*)&msgbuf,(strlen(msgbuf.mtext)+1)*sizeof(msgbuf.mtext[0]),IPC_NOWAIT);
		if (msgsz < 0) {
			if(errno == EIDRM) {
				printf("消息队列（0x%08x/%d)已被销毁!!!\n",key,msgid);
				break;
			}
			else {
				perror("msgsnd");
				return -1;
			}
		
		}
		else 
			printf("%04ld<%s\n",msgsz,msgbuf.mtext);//消息回显
	
	}
	
	printf("结束了！\n");
	
	return 0;
}

2、代码完成后编译一下

在这里插入图片描述
使用ls查看一下

3、启动运行,传递第一个消息队列

在这里插入图片描述

4、可以使用ipcs -q查看消息队列的信息

在这里插入图片描述
● 我们发现msgid可以为0
● 消息队列中已经存储了一条消息了,但是还没人消费

5、接收部分的代码

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/msg.h>

int main (void) {
	printf("获取消息队列...\n");
	key_t key = ftok(".",100);
	if(key == -1){
		perror("ftok");
		return -1;
	}
	
	int msgid = msgget(key,0);
	if(msgid == -1){
		perror("msggeet");
		return -1;
	}
	
	printf("从消息队列（0x%08x/%d)中接收消息...\n",key,msgid);
	
	
	for(;;){
		struct {
			long mtype;
			char mtext[1024];
		}msgbuf;
		
		ssize_t msgsz = msgrcv(msgid,(void*)&msgbuf,sizeof(msgbuf.mtext)-sizeof(msgbuf.mtext[0]),0,MSG_NOERROR);
		if (msgsz < 0) {
			if(errno == EIDRM) {
				printf("消息队列（0x%08x/%d)已被销毁!!!\n",key,msgid);
				break;
			}
			else {
				perror("msgrcv");
				return -1;
			}
		
		}
		else 
			printf("%04ld<%s\n",msgsz,msgbuf.mtext);
	
	}
	
	printf("结束了！\n");
	
	return 0;
}

6、同样的编译然后运行

最终的效果就是这样了
在这里插入图片描述

7、代码封装

示例代码解析
● msg_que.h

/********************************
程序功能：进程通信-消息队列（system V）
author:zyh
date:2021.5.21
*********************************/

#ifndef _MSG_QUE_H_
#define _MSG_QUE_H_

#ifdef __cplusplus
extern "C" {
    #endif

    /*
注意：进程通信消息队列的总缓冲区大小有限制，传输的消息量比较多的时候，就不适合使用
在Linux中，/proc/sys/kernel/msgmax和/proc/sys/kernel/msgmnb文件记载了消息缓冲队列的大小
其中，kernel.msgmax表示消息大小的最大值，kernel.msgmnb表示消息缓冲区的最大值。
*/

    //#define MSG_FILE "/tmp/msgque"  //进程通信共有的文件

    #define MAX_QUEUE_TEXT_LENGTH 1024*2  //发送消息最大长度
    struct msg_form {
        long mtype;//类型
        char mtext[MAX_QUEUE_TEXT_LENGTH];//消息
    };

    typedef enum { //类型(类型必须大于0)
        NONE = 0,
        TYPE_1_MSG,
        TYPE_2_MSG,
        TYPE_3_MSG,
        TYPE_4_MSG,
        TYPE_5_MSG,
    }MSG_QUE_TYPE;
    /**
函数功能：获取文件路径key值
入参: path:文件路径，例如：/tmp/msgque
出参：
返回：成功返回key值，失败返回-1
**/
    int get_path_key(const char *path);

    /**
函数功能：创建消息队列，返回消息队列的标识
入参: key:消息队列名
出参：无
返回：成功返回消息队列的标识，失败返回-1
**/
    int creatMsgQue(int key);

    /**
函数功能：消息队列的删除
入参:msqid:消息队列的标识 
出参：无
返回：成功返回0，失败返回-1
**/	
    int deleteMsgQue(int msgid);

    /**
函数功能：发送消息
入参:
	msgid:由msgget函数返回的消息队列的标识码，即将消息添加到那个消息队列中。
	type:消息类型
	msg:发送的消息
	length：消息长度
出参：无
返回：成功返回0，失败返回-1
**/
    int sndMsgQue(int msgid, int type, char *msg, int length);

    /**
函数功能：从消息队列中堵塞接收消息
入参:msgid:为读的对象，即从哪个消息队列获取的消息
	type:消息类型，0的话，函数将不做类型检查而自动返回队列中的最旧的消息。
	rcvBuf：接收消息缓冲区
	bufSize：接收消息缓冲区大小
出参：rcvBuf:接收消息的缓冲区
返回：成功返回接收到的实际字节数，失败返回-1
解除阻塞的条件有以下三个：
1、消息队列中有了满足条件的消息。
2、消息队列被删除。
3、用msgrcv()的进程被信号中断。
**/	
    int blockRcvMsgQue(int msgid, int type, char rcvBuf[], int bufSize);

    /**
函数功能：从消息队列中不堵塞接收消息
入参:
	msgid:为读的对象，即从哪个消息队列获取的消息
	type:消息类型，0的话，函数将不做类型检查而自动返回队列中的最旧的消息。
	rcvBuf：接收消息缓冲区
	bufSize：接收消息缓冲区大小
出参：rcvBuf:接收消息的缓冲区
返回：成功返回接收到的实际字节数，-1：消息队列为空
**/	
    int noBlockRcvMsgQue(int msgid, int type, char *rcvBuf, int bufSize);

    #ifdef __cplusplus
}
#endif

#endif

● msg_que.c

/********************************
程序功能：进程通信-消息队列（system V）
author:zyh
date:2021.5.21
*********************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>
#include "msg_que.h"


/**
函数功能：获取文件路径key值
入参: path:文件路径，例如：/tmp/msgque
出参：
返回：成功返回key值，失败返回-1
**/
int get_path_key(const char *path)
{
    key_t key;
    //获取key值,key代表要创建的消息队列的标识， 即为ipc键
    key = ftok(path, 'z');
    if (0 > key) { //第一个参数代表路径，第二个参数代表权限只使用8bits
        perror("ftok error");
        return -1;
    }
    return key;
}

/**
函数功能：创建消息队列，返回消息队列的标识
入参: key:消息队列名
出参：无
返回：成功返回消息队列的标识，失败返回-1
**/
int creatMsgQue(int key)
{
    int msqid;

    /*
    key_t key;
	//获取key值,key代表要创建的消息队列的标识， 即为ipc键
    if((key = ftok(MSG_FILE,'z')) < 0) { //第一个参数代表路径，第二个参数代表权限只使用8bits
        perror("ftok error");
        return -1;
    }
	*/
    printf("Message Queue - key is: %d\n", key);

    //创建消息队列，第一个参数 key：为由ftok创建的key值，第二个参数 msgflg：用来确定消息队列的访问权限。
    if (0 > (msqid = msgget(key, IPC_CREAT | 0777))) { //第二个参数 用来确定消息队列的访问权限。返回消息队列的标识 如果这个消息队列已经存在，则返回ID
        perror("msgget error");
        return -1;
    }

    return msqid;
}

/**
函数功能：消息队列的删除
入参:msqid:消息队列的标识 
出参：无
返回：成功返回0，失败返回-1
**/	
int deleteMsgQue(int msgid)
{
    int ret = 0;

    ret = msgctl(msgid, IPC_RMID, NULL);
    if (0 > ret) {
        perror("msgctl");
        return -1;
    }

    return 0;
}

/**
函数功能：发送消息
入参:
	msgid:由msgget函数返回的消息队列的标识码，即将消息添加到那个消息队列中。
	type:消息类型
	msgBuff:发送的消息
	length：消息长度
出参：无
返回：成功返回0，失败返回-1
**/	
int sndMsgQue(int msgid, int type, char *msg, int length)
{
    int ret = 0;
    struct msg_form msgbuf;
    memset(&msgbuf, 0, sizeof(msgbuf));

    if (length >= (int)sizeof(msgbuf.mtext)) {
        fprintf(stderr, "msg length is too long\n");
        return -1;
    }

    msgbuf.mtype = type;
    memcpy(msgbuf.mtext, msg, length);
    //ret = msgsnd(msgid, (void*)&msgbuf, sizeof(msgbuf) - sizeof(long), IPC_NOWAIT);//当队列满时不阻塞，立刻返回
    ret = msgsnd(msgid, (void*)&msgbuf, length, IPC_NOWAIT);//当队列满时不阻塞，立刻返回
    if (0 > ret) {
        perror("msgsnd");
        return -1;
    }

    return 0;
}

/**
函数功能：从消息队列中堵塞接收消息
入参:msgid:为读的对象，即从哪个消息队列获取的消息
	type:消息类型，0的话，函数将不做类型检查而自动返回队列中的最旧的消息。
	rcvBuf：接收消息缓冲区
	bufSize：接收消息缓冲区大小
出参：rcvBuff:接收消息的缓冲区
返回：成功返回接收到的实际字节数，失败返回-1
解除阻塞的条件有以下三个：
1、消息队列中有了满足条件的消息。
2、消息队列被删除。
3、用msgrcv()的进程被信号中断。
**/	
int blockRcvMsgQue(int msgid, int type, char rcvBuf[], int bufSize)
{
    int ret = 0;
    struct msg_form msgbuf;
    memset(&msgbuf, 0, sizeof(msgbuf));

    ret = msgrcv(msgid, (void*)&msgbuf, sizeof(msgbuf) - sizeof(long), type, 0);//没有指定IPC_NOWAIT，进程阻塞，挂起执行直至有了指定类型的消息
    if (0 > ret) {
        perror("msgrcv");
        return -1;
    }

    //printf("rcv size ret=%d\n", ret);
    //memcpy(rcvBuf, msgbuf.mtext, ret);
    memcpy(rcvBuf, msgbuf.mtext, bufSize);
    return ret;
}

/**
函数功能：从消息队列中不堵塞接收消息
入参:
	msgid:为读的对象，即从哪个消息队列获取的消息
	type:消息类型，0的话，函数将不做类型检查而自动返回队列中的最旧的消息。
	rcvBuff：接收消息缓冲区
	rcvSize：接收消息缓冲区大小
出参：rcvBuff:接收消息的缓冲区
返回：成功返回接收到的实际字节数，-1：消息队列为空
**/	
int noBlockRcvMsgQue(int msgid, int type, char *rcvBuf, int bufSize)
{
    int ret = 0;
    struct msg_form msgbuf;
    memset(&msgbuf, 0, sizeof(msgbuf));

    ret = msgrcv(msgid, (void*)&msgbuf, sizeof(msgbuf) - sizeof(long), type, IPC_NOWAIT);//不阻塞,如果消息队列为空，则返回一个ENOMSG
    if (0 > ret) {
        //perror("msgrcv");
        return -1;
    }
    //printf("rcv size ret=%d\n", ret);
    memcpy(rcvBuf, msgbuf.mtext, bufSize);
    return ret;
}

● send_demo.c-发送端（发送两种类型的数据）

/********************************
程序功能：进程通信
author:zyh
date:2021.5.21
*********************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include "msg_que.h"

#define MSG_QUE_KEY_ID 45464 //消息队列标识
int main () 
{

    int msgid = -1;
    char msgBuff[256] = {0};
    int i = 0;

    msgid = creatMsgQue(MSG_QUE_KEY_ID);
    if (0 > msgid) {
        printf("start msgQue failed\n");
        return -1;
    }

    printf("start msgQue success (msgid=%d)\n", msgid);
    while (1) {
        sprintf(msgBuff, "TYPE_1_MSG:%d", i);
        sndMsgQue(msgid, 1, msgBuff, strlen(msgBuff));

        sprintf(msgBuff, "TYPE_2_MSG:%d", i);
        sndMsgQue(msgid, 2, msgBuff, strlen(msgBuff));
        i++;
        sleep(2);
    }

    deleteMsgQue(msgid);

    return 0;
}

● recv1_demo.c 接收端接收类型1的数据

/********************************
程序功能：进程通信
author:zyh
date:2021.5.21
*********************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include "msg_que.h"

#define MSG_QUE_KEY_ID 45464 //消息队列标识
int main () 
{

    int msgid = -1;
    char rcvBuff[256] = {0};

    msgid = creatMsgQue(MSG_QUE_KEY_ID);
    if (0 > msgid) {
        printf("start msgQue failed\n");
        return -1;
    }
    printf("start msgQue success (msgid=%d)\n", msgid);

    while (1) {
        memset(rcvBuff, 0, sizeof(rcvBuff));
        blockRcvMsgQue(msgid, 1, rcvBuff, sizeof(rcvBuff));
        printf("TYPE_1_MSG:%s\n", rcvBuff);
    }

    deleteMsgQue(msgid);
    return 0;
}

三、POSIX(mq)消息队列

直接使用系统接口：
编译指令gcc mq_test.c -o test -Wall -lrt

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

typedef struct {
    int a;
    int b;
    char str[32];
} my_data_t;

/*
- 我们首先打开一个进程通信--POSIX (mq)消息队列，如果它不存在，我们会创建一个。这是通过指定O_CREAT标志实现的。
- 我们设置消息队列的属性，包括队列的最大消息数，每个消息的最大长度，以及队列当前的消息数。
- 我们在mq_receive()调用中传递一个指向存储消息的缓冲区的指针。如果当前没有消息，此调用将会阻塞，直到接收到一个消息。为了进行非阻塞接收，可以在打开消息队列时设置mq_flags字段为O_NONBLOCK。
- 用mq_close关闭消息队列和mq_unlink删除消息队列是有序执行，因为直到所有使用此队列的进程都关闭后，队列才可以被删除
*/
int main()
{
    mqd_t mqd;
    struct mq_attr attr;
    attr.mq_flags = O_NONBLOCK;    /*0或O_NONBLOCK，0堵塞，O_NONBLOCK为非阻塞 */
    attr.mq_maxmsg = 128;  /* 队列最大消息数 */
    attr.mq_msgsize = 256;  /* 队列每个消息的最大长度 */
    attr.mq_curmsgs = 0;  /* 队列当前消息数 */

    //1. 创建或打开消息队列
    mqd = mq_open("/mq_name", O_CREAT | O_RDWR, 0644, &attr);//必须以/开头，并且后续不能有其他/，形如/abc
    if (0 > mqd) {
        perror("mq_open");
        return -1;
    }

    mq_getattr(mqd, &attr);//获取mqd指向的消息队列的属性，存放到attr结构体，成功:0，出错:-1
    printf("attr.mq_curmsgs = %ld\n", attr.mq_curmsgs);

    /*2. 发送消息
	prio:消息的优先级：它是一个小于MQ_PRIO_MAX的数，数值越大，优先级越高。
		posix消息队列在调用mq_receive时，总是返回队列中最高优先级的最早消息。
		如果消息不需要设定优先级，那么可以在mq_send时设置msg_prio为0，mq_receive的msg_prio设置为NULL。
	*/
    char msg[256] = "hello";
    int prio = 0;
    mq_send(mqd, msg, strlen(msg), prio);//如果队列已满，在堵塞模式下，将阻塞，直到队列未满，成功返回0，失败返回-1

    //发送自定义结构体
    my_data_t data = {1, 2, "zhou"};
    mq_send(mqd, (char *)&data, sizeof(data), prio);

    //
    mq_getattr(mqd, &attr);//获取mqd指向的消息队列的属性，存放到attr结构体，成功:0，出错:-1
    printf("attr.mq_curmsgs = %ld\n", attr.mq_curmsgs);


    //3. 接收消息
    char buffer[256] = {0};
    int rcv_bytes = 0;
    /*msg_len参数要大于等于mq_msgsize的，如果小于该值，就会返回EMSGSIZE错误；
	如果队列为空，在堵塞模式下，将阻塞直到有消息为止, 返回指定消息队列中最高优先级的最早消息，成功返回读取消息的内容的字节数，出错返回-1
	*/
    rcv_bytes = mq_receive(mqd, buffer, attr.mq_msgsize, NULL);
    printf("rcv_bytes=%d, buffer=%s\n", rcv_bytes, buffer);

    my_data_t rcv_data = {0};
    rcv_bytes = mq_receive(mqd, (char *)&rcv_data, attr.mq_msgsize, NULL);
    printf("rcv_data.a=%d, rcv_data.b=%d, rcv_data.str=%s\n", rcv_data.a, rcv_data.b, rcv_data.str);

    //4. 关闭消息队列
    mq_close(mqd);  /* 关闭消息队列 */
    mq_unlink("/mq_name");  /* 删除消息队列 */
}

附录

链接: 学习笔记

￥风笛￥
关注
  • 21
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux--消息队列
m0_59052131的博客
03-13 1560
消息队列的创建和读取相关注意事项和源代码及其执行结果。
linux笔记-数据结构——队列
qq_45315904的博客
02-21 1312
基本概念 队列是最常见的概念，日常生活经常需要排队，仔细观察队列会发现，队列是一种逻辑结构，是一种特殊的线性表。特殊在： 只能在固定的两端操作线性表 只要满足上述条件，那么这种特殊的线性表就会呈现一种“先进先出”的逻辑，这种逻辑就被称为队列。 由于约定了只能在线性表固定的两端进行操作，于是给队列这种特殊的线性表的插入删除，起个特殊的名称： 队头：可以删除节点的一端 队尾：可以插入节点的一端 入队：将节点插入到队尾之后，函数名通常为enQueue() 出队：将队头节点从队列中剔除，函数名通常为o
Linux下使用C语言实现进程间的通讯-消息队列
weixin_55491446的博客
07-06 515
参考网上资源：https://www.bookstack.cn/read/linuxapi/docs-msgsnd-msgrcv.md该类型需要自己在编程时定义，用于存储消息的内容。下面给出一个范例，注意，里面的名称随意。消息类型必须要有，且不为0long mtype;//消息类型 char mtext [ 1 ];//数组大小编程时自己指定 };用于linux下进程间的通讯；了解在linux下使用命令创建、查看、删除消息队列，并修改其属性；使用c代码实现消息队列的创建等。
[Linux]-进程间通信之消息队列
levi的博客
06-22 2364
之前我们使用过的管道比较适用于较少进程之间的通信，那么如果想要实现多个进程之前的通信的话，我们需要使用消息队列消息队列具有如下特点1.消息队列是消息的链表，存放于内存中，内核维护消息队列2.消息队列中的消息是有类型的3.消息队列中的消息是有格式的4.消息队列可实现消息随机查询，并且不一定要遵循先进先出的顺序，而是每个进程可以按照感兴趣的类型进行读取5.与管道相同，读出数据后，消息队列对应数据会被删除6.每个管道都有消息队列标识符，在整个系统中是唯一的7.消息队列允许。
Linux内核工作队列workqueue详解
weixin_44810385的博客
07-26 2358
linux 内核 workqueue详解
linux c消息队列实现
04-02
发送端读取指定的文件，并且按照环境变量中设置的消息队列键值进行发送。如果要改代码，只要把键值改一下，结构体储存要发送的消息的那个数组对应改成自己想发送的值，就可以很好的实现功能。接收端同样按环境变量...
输入输出队列-LinuxC
最新发布
03-04
本文将深入探讨Linux C中的输入输出队列及其相关知识点。 首先，我们要明确I/O模型在操作系统中的地位。在Linux内核中，输入输出通常通过缓冲区进行管理，以提高效率。当一个进程请求读取或写入数据时，数据并不...
linux-c消息队列例子.zip_linux c_linux-c消息队列例子_pushnrz_消息队列
07-15
利用消息队列进行通信 linux c 嵌入式
linux-msgqueue-test.rar_linux 消息队列
07-13
本项目名为“linux-msgqueue-test”，包含一个名为“msgqueue-test.c”的源代码文件，显然是为了演示如何在Linux环境下使用消息队列。 **消息队列的定义** 消息队列是一种特殊的文件系统对象，由内核管理，可以被多...
linux.rar_linux c消息队列
07-14
linux下的进程通讯机制的代码例子。消息队列以及共享内存。
linux各种队列
dickjtk0的专栏
07-22 959
普通队列 一、定义工作入口项 struct workqueue_struct *suspend_work_queue; 二、创建单线程的工作队列 suspend_work_queue = create_singlethread_workqueue("suspend");     if (suspend_work_queue == NULL) {         ret = -ENOME
Linux编程基础 5.2：消息队列
爱学习爱运动的专栏
05-05 2096
内容后面来补充
【Linux篇】消息队列
m0_66492811的博客
08-22 293
消息队列
C/C++网络编程总结与ZeroMQ
jmppok的专栏
01-15 8828
现在几乎所有C/C++的后台程序都需要进行网络通讯，其实现方法无非有两种：使用系统底层socket或者使用已有的封装好的网络库。本文对两种方式进行总结，并介绍一个轻量级的网络通讯库ZeroMQ。
linux应用 进程间通信之消息队列(POSIX)
cesheng3410的博客
02-14 1330
本文阐述了进程间通信之消息队列(POSIX)的定义、应用场景、优缺点等，列举了编程中使用的接口，编写了测试用例测试相关功能。
Linux·工作队列
m0_64560763的博客
08-24 2324
Linux·工作队列
Linux C 数据结构——队列
热门推荐
知秋一叶
12-28 1万+
还是先放这张图，以便对比和理解：      队列是限制在两端进行插入操作和删除操作的线性表，允许进行存入操作的一端称为“队尾”，允许进行删除操作的一端称为“队头”。当线性表中没有元素时，称为“空队”。特点：先进先出（FIFO）。
Linux中的消息队列、共享内存，你确定都掌握了吗？
2004v2004的专栏
10-09 973
Linux中的消息队列
linux 消息队列 c语言
05-13
Linux消息队列是一种进程间通信（IPC）机制，可以在不同进程间传递消息。它提供了一个缓冲区，使生产者进程可以将消息放置在其中，而消费者进程则可以从中读取消息。 在C语言中，可以使用系统调用函数msgget()、msgsnd()、msgrcv()和msgctl()来使用消息队列。msgget()用于创建或访问消息队列，msgsnd()用于将消息发送到消息队列，msgrcv()用于从消息队列中接收消息，msgctl()用于对消息队列进行控制。 使用消息队列可以解决多个进程之间的数据交换问题，可以避免临界区竞争的问题，提高系统的并发性能。消息队列也可以用于进程间同步，保证多个进程间的执行顺序。 值得注意的是，消息队列的缓冲区是有限的，如果缓冲区已满，新的消息将无法发送。因此，在使用消息队列时需要考虑缓冲区大小和使用频率等因素，以避免消息丢失或消息堆积导致系统性能下降的问题。 总之，Linux消息队列是一种常用的进程间通信机制，在C语言中使用较为方便。合理地使用消息队列可以提高系统的并发性能和数据传输的可靠性，是程序设计中很重要的一个环节。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值