进程间通信-队列

最新推荐文章于 2023-06-22 15:12:47 发布
最新推荐文章于 2023-06-22 15:12:47 发布
阅读量812 收藏
点赞数
分类专栏： linux 进程间通信 文章标签： 进程间通信 队列 msgsnd msgrcv msgget
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1009563517/article/details/47333773
版权


消息队列
消息队列是通过标识来引用，消息队列类似于一个消息链表，通过队列标识来引用，标识通过key来获取msgget(key_t key, int flag)。


创建队列过程：
1.确定队列的key，key可以自定义，也可以利用ftok来获取一个key
①利用ftok来得到一个key值ftok(const char * path, int id)路径必须是一个存在的文件路径，否则一直阻塞在那里id取值范围0-255
②key自定义，然后把key值放在公共头文件里，方便包含该头文件的其他文件使用
③key自定义，然后把key放在一个文件中，不同进程都可以通过访问该文件来访问这个key
2.通过key来创建消息队列并获取队列标识
3.向队列发送数据msgsnd或读取数据msgrcv来进行通信


读取消息队列中的数据是先进先出或者按照设置的读取的数据类型来随机读取
创建消息队列的进程结束，但是消息队列以及队列中的数据还是依然存在，除非显示的删除：
1.由其他进程读或者删除消息队列
2.由系统删除


函数msgget
       msgget - get a message queue identifier
       获取消息队列标识

函数概述
       #include <sys/types.h>
       #include <sys/ipc.h>
       #include <sys/msg.h>

       int msgget(key_t key, int msgflg);

       返回与key相关的队列的标识，如果key的值为IPC_PRIVATE或者key的值不等于其他已存在的队列的key，而且msgflg指定了IPC_CREAT，则创建一个新的队列

       如果msgflg设置为IPC_CREAT|IPC_EXCL，则如果对应的key已经存在于已存在的队列，则创建失败，errno为EEXIST。

       在创建队列的时候，参数msgflg最低有效位是定义队列权限的，这些权限位和open的参数mode用法一样除可执行权限不能用
       如果一个队列被创建，那么与它相关的结构msqid_ds 会被初始化：
       msg_perm.cuid and msg_perm.uid会被设置成引用队列的进程的用户id
             
       msg_perm.cgid and msg_perm.gid会被设置成引用队列的进程的组id
            
       msg_perm.mode低9位与msgflg的低9位对应
             
       msg_qnum, msg_lspid, msg_lrpid, msg_stime and msg_rtime初始化为0
             
       msg_ctime 设为当前时间
             
       msg_qbytes 会初始化为系统限制队列的最大字节数
            
       如果要创建的队列已经存在而且具有读写权限，则检查是否成功可以查看返回值 

       成功返回队列的id（非负数），失败返回-1

       失败则会设置errno，值描述如下：
       EACCES  参数key对应的队列已经存在，且调用进程对队列没有权限，也没有CAP_IPC_OWNER（绕过检查系统对对象的权限）
       EEXIST  参数key对应的队列已经存在，而且msgflg设置为  IPC_CREAT and IPC_EXCL
       ENOMEM  一个新的队列会被创建，但是系统没有更多的内存了
       ENOSPC  超过了系统允许创建的队列中最大存储数据（65536）  

注意
       1.IPC_PRIVATE 类型是key_t，不是一个标志字段，当用于参数key调用时，系统会忽略其他参数除msgflg的低9位的权限位，关于megget调用相关联的系统限制：MSGMNI 系统允许的队列最大个数，与系统相关（linux 限制值可通过/proc/sys/kernel/msgmni修改或获取 31683）
       2.在linux2.3.20版本以前，当调用msgget()而队列已被删除时会返回EIDRM
       3.创建队列时使用IPC_PRIVATE会有很多不确定因素，建议使用IPC_NEW

#define FUN1_ID			10001
#define FUN2_ID			10002
#define usr_path		"/usr/test/ok/test"
#define usr_id			109870


typedef struct _ipc_data_info_
{
	long	s_type;
	char	s_data[70000];
}ipc_data_info;

int ipc_msg_fun1(pid_t a_id)
{
	key_t				b_msg_key;
	int					b_msg_id;
	int					b_ret, b_loop, b_id;
	char				b_tmp_buf[1024] = {0};
	char			  *	b_tmp_ptr = (char *)malloc(65530);
	ipc_data_info		b_ipc_snd = {0}, b_ipc_rcv = {0};
	struct msqid_ds		b_ipc_buf = {0};

	//msgctl();

	//b_msg_key = ftok(usr_path, usr_id);
	b_msg_key = ftok(usr_path, usr_id);
	if(b_msg_key < 0)
	{
		printf("ftok fail %d, line = %d, fun = %s, file = %s\n", \
			b_msg_key, __LINE__, __func__, __LINE__);
		return -1;
	}
	
	b_msg_id = msgget(b_msg_key, IPC_CREAT|0666);
	if(b_msg_id < 0)
	{
		printf("msgget fail %d, line = %d, fun = %s, file = %s\n", \
			b_msg_id, __LINE__, __func__, __LINE__);
		return -1;
	}

	memset(&b_ipc_buf, 0, sizeof(b_ipc_buf));
	msgctl(b_msg_id, IPC_STAT, &b_ipc_buf);

	printf("id = %d, key = %d, limit = %d\n", b_msg_id, b_msg_key, b_ipc_buf.msg_qbytes);
	//msgctl(b_msg_id, IPC_RMID, &b_ipc_buf);

	
	
	b_ipc_snd.s_type = FUN1_ID;
	b_ipc_rcv.s_type = FUN2_ID;
	b_loop = 0;
	while(1)
	{
		memset(b_tmp_ptr, 0, sizeof(b_tmp_ptr));
		sprintf(b_tmp_ptr, "test_data %d", b_loop);
		memset(b_ipc_snd.s_data, 0, sizeof(b_ipc_snd.s_data));
		memcpy(b_ipc_snd.s_data, b_tmp_ptr, strlen(b_tmp_ptr));
		b_ret = msgsnd(b_msg_id, &b_ipc_snd, 1024, 0);
		if(b_ret < -1)
		{
			printf("msgsnd fail %d, line = %d, fun = %s, file = %s\n", b_ret, __LINE__, __func__, __FILE__);
			return -1;
		}
		printf("send data success data = %s\n", b_ipc_snd.s_data);
		#if 0
		b_ret = msgrcv(b_msg_id, &b_ipc_rcv, 1024, b_ipc_rcv.s_type, 0);
		if(b_ret < -1)
		{
			printf("msgsnd fail %d, line = %d, fun = %s, file = %s\n", b_ret, __LINE__, __func__, __FILE__);
			return -1;
		}
		printf("recv data = %s\n", b_ipc_rcv.s_data);
		#endif
		b_loop++;
		if(b_loop > 10000)
		{
			b_loop = 0;
		}
		sleep(2);
	}
	
	return 0;
}

int ipc_msg_fun2(pid_t a_id)
{
	key_t				b_msg_key;
	int					b_msg_id;
	int					b_ret, b_loop;
	char				b_tmp_buf[1024] = {0};
	ipc_data_info		b_ipc_snd = {0}, b_ipc_rcv = {0};
	
	b_msg_key = ftok(usr_path, usr_id);
	if(b_msg_key < 0)
	{
		printf("ftok fail %d, line = %d, fun = %s, file = %s\n", \
			b_msg_key, __LINE__, __func__, __LINE__);
		return -1;
	}
	
	b_msg_id = msgget(b_msg_key, IPC_CREAT|0666);
	if(b_msg_id < 0)
	{
		printf("msgget fail %d, line = %d, fun = %s, file = %s\n", \
			b_msg_id, __LINE__, __func__, __LINE__);
		return -1;
	}

	b_ipc_snd.s_type = FUN2_ID;
	b_ipc_rcv.s_type = FUN1_ID;
	b_loop = 0;
	while(1)
	{
		#if 0
		memset(b_tmp_buf, 0, sizeof(b_tmp_buf));
		sprintf(b_tmp_buf, "test_data1 %d", b_loop);
		memset(b_ipc_snd.s_data, 0, sizeof(b_ipc_snd.s_data));
		memcpy(b_ipc_snd.s_data, b_tmp_buf, strlen(b_tmp_buf));
		b_ret = msgsnd(b_msg_id, &b_ipc_snd, strlen(b_ipc_snd.s_data), 0);
		if(b_ret < -1)
		{
			printf("msgsnd fail %d, line = %d, fun = %s, file = %s\n", b_ret, __LINE__, __func__, __FILE__);
			return -1;
		}
		printf("send data success\n");
		#endif
		memset(&b_ipc_rcv, 0, sizeof(b_ipc_rcv));
		b_ret = msgrcv(b_msg_id, &b_ipc_rcv, 1024, b_ipc_rcv.s_type, 0);
		if(b_ret < -1)
		{
			printf("msgsnd fail %d, line = %d, fun = %s, file = %s\n", b_ret, __LINE__, __func__, __FILE__);
			return -1;
		}
		printf("recv data = %s\n", b_ipc_rcv.s_data);
		#if 0
		b_loop++;
		if(b_loop > 10000)
		{
			b_loop = 0;
		}
		#endif
		sleep(1);
	}
	
	return 0;
}

int main()
{
	/*============================================*/
	/*队列*/
	int			b_loop = 0, b_ret;
	pid_t		b_id[10];

	b_id[b_loop] = fork();
	if(b_id[b_loop] < 0)
	{
		printf("fork fail %d, line = %d, fun = %s, file = %s\n", b_id, __LINE__, __func__, __FILE__);
		return -1;
	}
	else if(0 == b_id[b_loop])
	{
		/*子进程*/
		ipc_msg_fun1(b_id[b_loop]);
	}
	b_loop++;

	b_id[b_loop] = fork();
	if(b_id[b_loop] < 0)
	{
		printf("fork fail %d, line = %d, fun = %s, file = %s\n", b_id, __LINE__, __func__, __FILE__);
		return -1;
	}
	else if(0 == b_id[b_loop])
	{
		/*子进程*/
		ipc_msg_fun2(b_id[b_loop]);
	}
	b_loop++;

	while(1)
	{
		b_ret = wait(NULL);
		if(b_ret < -1)
		{
			printf("son process over %d, line = %d, fun = %s, file = %s\n", b_ret, __LINE__, __func__, __FILE__);
			break;
		}
	}

	return 0;
	/*============================================*/
}

浪里狼
关注
专栏目录
【C++服务器入门基础------5.IPC进程间通信--消息队列】
qq_39583373的博客
02-23 1320
c++服务器入门系列 大学生寒假在家里过于无聊，整理一下以前学过的知识，顺便复习一下，水平较低，专业性不强，仅供参考。
【进程】进程间通信----消息队列
金金金金金的博客
11-12 620
1.特性 队列的特性是先进先出，消息队列也是满足先进先出的特性的，内核当中实现消息队列的时候，是采用链表这个结构体 消息队列当中的元素是有类型的，每一种类型是有优先级概念的—同一类型保证先进先出的特性   2.实现接口 int msgget(key_t key, int msgflg) int msgsnd(int msqid, const void* msgp, size_t msgsz, long msgtyp, int msgflg) msgflg：IPC_NOWAIT：非阻塞模式  
[Linux]-进程间通信之消息队列
最新发布
levi的博客
06-22 3498
之前我们使用过的管道比较适用于较少进程之间的通信，那么如果想要实现多个进程之前的通信的话，我们需要使用消息队列消息队列具有如下特点1.消息队列是消息的链表，存放于内存中，内核维护消息队列2.消息队列中的消息是有类型的3.消息队列中的消息是有格式的4.消息队列可实现消息随机查询，并且不一定要遵循先进先出的顺序，而是每个进程可以按照感兴趣的类型进行读取5.与管道相同，读出数据后，消息队列对应数据会被删除6.每个管道都有消息队列标识符，在整个系统中是唯一的7.消息队列允许。
进程通信-消息队列
Gerald_Jones的博客
06-01 423
进程通信-消息队列  来源：https://blog.csdn.net/wh_sjc/article/details/70283843   进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。 IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。 以Linux中的C语言编程为例。 一、管道 管道，
python之路----进程三
weixin_34232617的博客
02-05 122
IPC--PIPE管道 #创建管道的类： Pipe([duplex]):在进程之间创建一条管道，并返回元组（conn1,conn2）,其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道 #参数介绍： dumplex:默认管道是全双工的，如果将duplex射成False，conn1只能用于接收，conn2只能用于发送。 #主要方法：...
Linux进程间通信-消息队列实例.pdf
07-11
【Linux进程间通信-消息队列实例】 在操作系统中，进程间通信（Inter-Process Communication, IPC）是多个进程共享数据、协调工作的重要机制。在Linux系统中，提供了多种进程间通信方式，如管道、信号量、共享内存...
操作系统+进程间通信-消息队列+实现聊天室功能
04-23
总之，通过这个项目，你不仅可以学习到操作系统中进程间通信的基本概念，还能掌握消息队列的具体使用方法，以及如何利用这些知识实现一个实用的聊天室应用。这将有助于深化对操作系统底层原理的理解，提高你的编程...
C#进程间通信-消息队列代码实例
12-04
本实例以C#语言为基础，详细讲解如何利用消息队列进行进程间通信。 首先，我们需要理解消息队列的基本概念。消息队列是一种存储和转发机制，它将消息从一个进程发送到另一个进程，而无需两者同时在线。消息队列的...
Linux进程间通信-信号量通信进程互斥实例.pdf
07-11
【Linux进程间通信】在操作系统中，进程间通信（Inter-Process Communication, IPC）是不同进程之间交换数据的重要机制。Linux提供了多种IPC方式，包括管道、消息队列、共享内存、信号量等。本实例主要关注的是...
进程间通信—消息队列
weixin_54131692的博客
10-09 240
进程间通信—消息队列
Linux学习通信阶段中 ftok msgget msgsnd msgrcv msgctl API相关介绍
m0_52983689的博客
02-21 374
1
系统编程之消息队列
fgfxgfx的博客
03-20 277
1.创建（获取）消息队列 msgget（） 函数声明： int msgget ( key_t key, int msgflg ) 返回值： message queue identifier on success失败的话返回-1 第一个参数：可以自己在开头用define宏定义一个任意数字 第二个参数，msgflg 控制的。它可以取下面的几个值： IPC_CREAT ： 如果消息队列对象不存在，则创建...
系统调用msgget()
Ethan_Novice的专栏
11-29 2155
如果希望创建一个新的消息队列，或者希望存取一个已经存在的消息队列，你可以使用系统调用msgget()。 　　系统调用：msgget(); 　　原型：int msgget(key_t key,int msgflg); 　　返回值：如果成功，返回消息队列标识符 　　如果失败，则返回-1：errno=EACCESS(权限不允许) 　　EEXIST(队列已经存在，无法创建) 　　EIDRM(队
linux的消息队列的创建和实现
weixin_59349642的博客
04-29 1748
目录回顾消息队列1 msgget函数 回顾 1 创建的有名管道时候 并不会产生fifo 而是在调用open函数 的时候才会 2 通过两个无血缘关系的进程 分别对有名管道读和写 3 读的时候没有数据 是因为有名管道没有数据 消息队列 消息的队列就是消息的链表 存放在内核态中 1 特定格式就是以链表的方式存在 2 每个节点都可以作为发送和接收的中间过渡方式。 3 因为链表的灵活 读取顺序可以打乱 4 并且每个链表都有独立的标识符 用于区分类型 1 msgget函数 ...
php使用msgget返回没权限,进程间通信之深入消息队列的详解
weixin_30844865的博客
03-28 217
最近在Hi3515上调试Qt与DVR程序，发现他们之间使用消息队列通信的，闲暇之余，就总结了一下消息队列，呵呵，自认为通俗易懂，同时，在应用中也发现了消息队列的强大之处。关于线程的管理(互斥量和条件变量)见：Linux线程管理必备:解析互斥量与条件变量的详解一、消息队列的特点1.消息队列是消息的链表,具有特定的格式,存放在内存中并由消息队列标识符标识.2.消息队列允许一个或多个进程向它写入与读取消...
linux的msgget函数,msgget()函数
weixin_39569753的博客
05-04 1496
msgget()函数被用来创建新的消息队列或获取已有的消息队列。其函数定义如下：系统调用： msgget()函数声明： int msgget ( key_t key, int msgflg )返回值： message queue identifier on success-1 on error: errno = EACCESS (permission denied)EEXIST (Queue ex...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值