消息队列和共享空间（8.6）

已于 2022-08-08 10:13:18 修改
阅读量68 收藏
点赞数
文章标签： c语言
于 2022-08-06 09:17:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51103493/article/details/126184302
版权

目录

1.要求AB进程做通信（使用队列）

A进程发送一句话，B进程接收打印

然后B进程发送给A进程一句话，A进程接收打印

重复1,2步骤，直到A进程或者B进程收到quit，退出AB进程

2.在第一题的基础上实现，AB进程能够随时收发数据（附加题）

A进程

B进程

A进程写入一个整型，在该整型后，写入一个字符串

B进程将共享内存中的整型以及字符串读取出来;

写入共享内存的进程

 输出内容的进程

 

1.要求AB进程做通信（使用队列）

  1. A进程发送一句话，B进程接收打印

  2. 然后B进程发送给A进程一句话，A进程接收打印

  3. 重复1,2步骤，直到A进程或者B进程收到quit，退出AB进程

2.在第一题的基础上实现，AB进程能够随时收发数据（附加题）

A进程

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

//消息包结构体
struct msgbuf
{
	long mtype; 		//消息类型，必须大于0 
	char mtext[128]; 	//消息内容，该成员类型可变
};


off_t len;

struct msgbuf rcv;
ssize_t res =0;
struct msgbuf snd;
int  msqid;
int msqid2;

void* callBack1(void* arg)
{
	while(1)
	{
		//发送消息包

		printf("请输入消息类型>>>");
		scanf("%ld", &snd.mtype);
		getchar(); 	//吸收垃圾字符

		printf("请输入>>>");
		fgets(snd.mtext, sizeof(snd.mtext), stdin);

		snd.mtext[strlen(snd.mtext)-1] = 0;
	if(strcasecmp(snd.mtext, "quit") == 0)
		{
			exit(0);
		}
		//阻塞方式发送，消息队列满了，阻塞
		if(msgsnd(msqid, &snd, sizeof(snd.mtext), 0) < 0)
		{
			perror("msgsnd");
			return NULL;
		}
	
		printf("A消息包发送成功\n");
	}
}


void* callBack2(void* arg)
{
	while(1)
	{
		res=msgrcv(msqid2,&rcv,sizeof(rcv.mtext),0,0);
		if(strcasecmp(snd.mtext, "quit") == 0)
		{
			exit(0);
		}
		if(res<0)
		{
			perror("msgrcv");
			return NULL;
		}
		printf("B res=%ld [%ld : %s]\n",res,rcv.mtype,rcv.mtext);


	}
}






int main(int argc, const char *argv[])
{
	//计算key值
	key_t key = ftok("./",1);
	if(key < 0)
	{
		perror("ftok");
		return -1;
	}
	printf("key = %#x\n", key);

	//计算key值
	key_t key2 = ftok("./",2);
	if(key2 < 0)
	{
		perror("ftok");
		return -1;
	}
	printf("key2 = %#x\n", key2);
	//创建一个消息队列
	msqid = msgget(key, IPC_CREAT|0664);
	if(msqid < 0)
	{
		perror("msgget");
		return -1;
	}
	printf("msqid = %d\n", msqid);

	//创建一个消息队列
	msqid2 = msgget(key2, IPC_CREAT|0664);
	if(msqid2 < 0)
	{
		perror("msgget");
		return -1;
	}
	printf("msqid2 = %d\n", msqid2);

	//创建一个线程
	pthread_t tid1;
	if(pthread_create(&tid1, NULL, callBack1,NULL) != 0)
	{
		perror("pthread_create");
		return -1;
	}

	//创建一个线程，
	pthread_t tid2;
	if(pthread_create(&tid2, NULL, callBack2, NULL) != 0)
	{
		perror("pthread_create");
		return -1;
	}


	pthread_join(tid1, NULL);
	pthread_join(tid2,NULL);

	return 0;
}

B进程

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

//消息包结构体
struct msgbuf
{
	long mtype; 		//消息类型，必须大于0 
	char mtext[128]; 	//消息内容，该成员类型可变
};
off_t len;

struct msgbuf rcv;
ssize_t res =0;
struct msgbuf snd;
int  msqid;
int msqid2;


void* callBack1(void* arg)
{
	while(1)
	{
		res=msgrcv(msqid,&rcv,sizeof(rcv.mtext),0,0);
	if(strcasecmp(snd.mtext, "quit") == 0)
	{
		exit(0);
	}	

	if(res<0)
	{
		perror("msgrcv");
		return NULL;
	}
	printf("A res=%ld [%ld : %s]\n",res,rcv.mtype,rcv.mtext);
	}


}

void* callBack2(void* arg)
{
	while(1)
	{
		//发送消息包

	printf("请输入消息类型>>>");
		scanf("%ld", &snd.mtype);
		getchar(); 	//吸收垃圾字符

		printf("请输入>>>");
		fgets(snd.mtext, sizeof(snd.mtext), stdin);
		snd.mtext[strlen(snd.mtext)-1] = 0;
	if(strcasecmp(snd.mtext, "quit") == 0)
		{
			exit(0);
		}	
		//阻塞方式发送，消息队列满了，阻塞
		if(msgsnd(msqid2, &snd, sizeof(snd.mtext), 0) < 0)
		{
			perror("msgsnd");
			return NULL;
		}
	
		printf("B消息包发送成功\n");
	}
}



int main(int argc, const char *argv[])
{
	//计算key值
	key_t key = ftok("./",1);
	if(key < 0)
	{
		perror("ftok");
		return -1;
	}
	printf("key = %#x\n", key);


	//计算key值
	key_t key2 = ftok("./",2);
	if(key2 < 0)
	{
		perror("ftok");
		return -1;
	}
	printf("key2 = %#x\n", key2);


	//创建一个消息队列
	msqid = msgget(key, IPC_CREAT|0664);
	if(msqid < 0)
	{
		perror("msgget");
		return -1;
	}
	printf("msqid = %d\n", msqid);




	//创建一个消息队列
	msqid2 = msgget(key2, IPC_CREAT|0664);
	if(msqid2 < 0)
	{
		perror("msgget");
		return -1;
	}
	printf("msqid2 = %d\n", msqid2);
	//创建一个线程
	pthread_t tid1;
	if(pthread_create(&tid1, NULL, callBack1,NULL) != 0)
	{
		perror("pthread_create");
		return -1;
	}

	//创建一个线程
	pthread_t tid2;
	if(pthread_create(&tid2, NULL, callBack2, NULL) != 0)
	{
		perror("pthread_create");
		return -1;
	}


	pthread_join(tid1, NULL);
	pthread_join(tid2,NULL);

	return 0;
}

3.

  1. A进程写入一个整型，在该整型后，写入一个字符串

  2. B进程将共享内存中的整型以及字符串读取出来;

写入共享内存的进程

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

int main(int argc, const char *argv[])
{


	//创建key值
	key_t key = ftok("./", 'a');
	if(key < 0)
	{
		perror("ftok");
		return -1;
	}
	printf("key = %#x\n", key);
	
	//创建共享内存
	int shmid = shmget(key, 32, IPC_CREAT|0664);
	if(shmid < 0)
	{
		perror("shmget");
		return -1;
	}
	printf("shmid = %d\n", shmid);

	//共享内存的映射
	void* shmaddr = shmat(shmid, NULL, 0);

	int* pint = (int*)shmaddr;
	*pint=1;
	char* pstr = (char*)(pint+1);
	strcpy(pstr, "hello world");



	system("ipcs -m");

	return 0;
}

 输出内容的进程

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

int main(int argc, const char *argv[])
{
	//创建key值
	key_t key = ftok("./", 'a');
	if(key < 0)
	{
		perror("ftok");
		return -1;
	}
	printf("key = %#x\n", key);
	
	//创建共享内存
	int shmid = shmget(key, 32, IPC_CREAT|0664);
	if(shmid < 0)
	{
		perror("shmget");
		return -1;
	}
	printf("shmid = %d\n", shmid);

	//共享内存的映射
	void* shmaddr = shmat(shmid,NULL ,0);
    int* pint=(int*)shmaddr;
	char* pstr = (char*)(pint+1);
//	strcpy(pstr, "hello world");
    
    printf("%d   ",*pint);
	printf("%s\n",pstr);



	return 0;
}

多多有点方
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LINUX 消息队列的容量探讨
wubing_2010的专栏
10-12 2647
LINUX消息队列可能不是你想的那样
linux消息队列最大空间,linux消息队列解析
weixin_35816805的博客
05-09 186
基本概念1.队列队列是信息的线性表,它的访问次序是先进先出(FIFO)。也就是说,置入队列中的第一个数据项将是从队列中第一次读出的数据项,置入的第二项将是读出的第二项,依此类推。这是队列允许的唯一存取操作,其它随机访问是不允许的。这种数据结构保证对数据资源的请求将严格按照先后顺序进行,因而可用于对事件的调度并起到I/O缓冲的作用。2.报文发送进程和接收进程进行信息的交换,一般是通过将信息划分为若干...
消息队列的设置
weixin_30482181的博客
11-07 394
/etc/sysctl.conf 修改 kernel.msgmni=1000 kernel.msgmax=81920 kernel.msgmnb=163840 MSGMNB 每个消息队列的最大字节限制。该文件指定一个消息队列的最大长度（bytes）。 MSGMNI 整个系统的最大数量的消息队列。该文件指定消息队列标识的最大数目，即系统范围内最大多少个消息队列。 MS...
进程间通信（IPC）-管道、消息队列、共享内存、信号、信号量、套接字
Unique-You的博客
05-02 6940
多进程：首先，先来讲一下fork之后，发生了什么事情。由fork创建的新进程被称为子进程（child process）。该函数被调用一次，但返回两次。两次返回的区别是子进程的返回值是0，而父进程的返回值则是新进程（子进程）的进程 id。将子进程id返回给父进程的理由是：因为一个进程的子进程可以多于一个，没有一个函数使一个进程可以获得其所有子进程的进程id。对子进程来说，之所以fork返回0给它，是...
模拟实现消息队列(以 RabbitMQ 为蓝本)
weixin_58697177的博客
08-09 1808
目录1. 需求分析1.1 介绍一些核心概念核心概念1核心概念21.2 消息队列服务器（Broker Server）要提供的核心 API1.3 交换机类型1.3.1 类型介绍1.3.2 转发规则：1.4 持久化1.5 关于网络通信1.5.1 客户端与服务器提供的对应方法1.5.2 客户端额外需要提供的方法1.6 消息应答模式1.7 需求分析小结2. 系统设计 - 模块设计3. 代码实现3.1 创建项目3.2 项目结构3.3 Exchange 类3.4 MSGQueue 类3.5 Binding 类3.6 M
复习专栏之---消息队列
lipviolet的博客
06-28 487
消息队列
【RabbitMQ】交换机、队列、可靠性保证和延迟消息
weixin_44976643的博客
11-16 231
文章目录前言1.初识MQ1.1.同步调用1.2.异步调用1.3.技术选型2.RabbitMQ2.1.安装2.2.收发消息2.2.1.交换机2.2.2.队列2.2.3.绑定关系2.2.4.发送消息2.3.数据隔离2.3.1.用户管理2.3.2.virtual host3.SpringAMQP3.1.导入Demo工程3.2.快速入门3.1.1.消息发送3.1.2.消息接收3.1.3.测试3.3.WorkQueues模型3.3.1.消息发送3.3.2.消息接收3.3.3.测试3.3.4.能者多劳3.3.5.总结3
C#常用命名空间
匆匆那年
09-15 4313
C#常用命名空间 一、基础命名空间 System 处理内建数据、数学计算、随机数的产生、环境变量、垃圾回收器及一些常见的异常和特征. System.Collections 包含了一些与集合相关的类型，比如列表、队列、位数组、哈希表和字典等. System.Collections.Generic
kd718和kb688参数_free命令常用参数详解及常用内存工具介绍
weixin_42365334的博客
01-13 1525
free命令常用参数详解及常用内存工具介绍作者：尹正杰版权声明：原创作品，谢绝转载！否则将追究法律责任。一.内存空间使用状态1>."-b"参数(以字节为单位显示内存使用情况)[root@node101.yinzhengjie.org.cn ~]# free -btotal usedfree shared buff/cache availableMem:82011...
UNIX环境高级编程和源代码
12-20
8.6 wait和waitpid函数 148 8.7 wait3和wait4函数 152 8.8 竞态条件 153 8.9 exec函数 156 8.10 更改用户ID和组ID 160 8.10.1 setreuid 和setregid函数 162 8.10.2 seteuid和 setegid函数 163 8.10.3 组ID 163 8.11 ...
《UNIX网络编程 第2版. 第2卷， 进程间通信(中文版)》（W·Richard Stevens[美] 著）
01-14
6.9 消息队列上使用select和poll 121 6.10 消息队列限制 122 6.11 小结 124 习题 124 第三部分 同步 第7章 互斥锁和条件变量 126 7.1 概述 126 7.2 互斥锁：上锁与解锁 126 7.3 生产者-消费者问题 127 7.4 对比上锁...
UNIX网络编程 卷2 进程间通信 带完整书签，完整目录
09-20
6.9 消息队列上使用select和poll 121 6.10 消息队列限制 122 6.11 小结 124 习题 124 第三部分 同步 125 第7章 互斥锁和条件变量 126 7.1 概述 126 7.2 互斥锁：上锁与解锁 126 7.3 生产者－消费者问题 127 ...
UNIX网络编程 卷2：进程间通信
06-16
　6.9 消息队列上使用select和poll 121 　6.10 消息队列限制 122 　6.11 小结 124 　习题 124 　第三部分 同步 　第7章 互斥锁和条件变量 126 　7.1 概述 126 　7.2 互斥锁：上锁与解锁 126 　7.3 生产者-消费者问题...
期末C语言单选题100道（含答案）
omit250的博客
06-13 423
15. 设a、b、c、d、m、n均为int型变量，且a=5、b=6、c=7、d=8、m=2、n=2，则逻辑表达式(m=a>b)&&(n=c>d)运算后，n的值为( )20. 设有：int a=1, b=2, c=3, d=4, m=3, n=3;执行 (m=a>b)||(n=c>d)后n的值为( )。4. 若x,a,b和c均是int型变量，则执行表达式x=(a=1,b=2)后x的结果为( )。13. 若a为int类型，且其值为3，则执行完表达式a+=a-=a*a后，a的值是( )
Linux C/C++ socket
qq_40135848的博客
06-13 1559
Linux C/C++ socket
C 程序结构
lly202406的博客
06-12 329
C语言是一种广泛使用的编程语言，以其高效性和灵活性而著称。本文将详细介绍C程序的基本结构，包括其组成部分和编程规范。
Day04 C语言语句
qq_59111928的博客
06-13 323
用户一般会把实现某些功能的语句整合在一起，构成一个语法单元；C语言标准的语法单位也被称为块，称为块语句。
QT自定义标题栏窗口，实现拖动及可拉伸效果
最新发布
06-20
QT自定义标题栏窗口，实现拖动及可拉伸效果
linux消息队列和共享内存
07-27
Linux中的消息队列和共享内存是用于进程间通信的两种机制。 消息队列是一种在内核中维护的消息缓冲区，用于在不同进程之间传递数据。发送进程将消息放入队列中，接收进程从队列中读取消息。消息队列可以通过消息...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值