信号通信与消息队列实现的通信：2024/2/23

已于 2024-02-23 21:58:46 修改
阅读量374 收藏 4
点赞数 6
文章标签： 算法 开发语言
于 2024-02-23 21:00:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FS223107/article/details/136262330
版权

作业1：将信号和消息队列的课堂代码敲一遍

1.1 信号

1.1.1 信号默认、捕获、忽略处理(普通信号)

代码：

#include <myhead.h>
void handler(int signo)
{
	if(signo==SIGINT){
		printf("用户键入 ctrl+c\n");
	}
}
int main(int argc, const char *argv[])
{
	//忽略信号
	if(signal(SIGINT,SIG_IGN)==SIG_ERR){
		perror("signal error");
		return -1;
	}
	/*
	//默认处理信号
	if(signal(SIGINT,SIG_IGN)==SIG_ERR){
		perror("signal error");
		return -1;
	}
	//捕获信号
	if(signal(SIGINT,handler)==SIG_ERR){
		perror("signal error");
		return -1;
	}
	*/
	while(1)
	{
		printf("123456\n");
		sleep(1);
	}
	return 0;
}

效果图：

1.1.2 SIGCHLD回收僵尸进程

代码：

#include <myhead.h>
void handler(int signo)
{
	if(signo==SIGCHLD){
		while(waitpid(-1,NULL,WNOHANG)>0);
		//waitpid(-1,NULL,WNOHANG);
	}
}
int main(int argc, const char *argv[])
{
	
	//捕获信号
	if(signal(SIGCHLD,handler)==SIG_ERR){
		perror("signal error");
		return -1;
	}
	//创建僵尸进程
	for(int i=0;i<5;i++)
	{
		if(fork()==0){
			sleep(1);
			exit(EXIT_SUCCESS);
		}
	}
	while(1);
	return 0;
}

效果图：

1.1.3 模拟出牌

代码：

#include <myhead.h>

//信号处理函数
void handler(int signo)
{
	if(signo==SIGALRM){
		printf("系统为您出了一张牌\n");
		alarm(5);
	}
}
int main(int argc, const char *argv[])
{
	//捕获SIGALRM信号
	if(signal(SIGALRM,handler)==SIG_ERR){
		perror("signal error");
		return -1;
	}
	alarm(5);             //启动定时器
	
	//出的牌
	char ch=0;
	while(1)
	{
		scanf("%c",&ch);
		getchar();

		printf("你出的牌为:%c\n",ch);
		alarm(5);
	}
	return 0;
}

效果图：

1.1.4 发送信号函数

代码：

#include <myhead.h>

void hander(int signo)
{
	if(signo==SIGUSR1){
		printf("大清亡了\n");
		raise(SIGKILL);
	}
}
int main(int argc, const char *argv[])
{
	//发送信号
	if(signal(SIGUSR1,hander)==SIG_ERR){
		perror("signal error");
		return -1;
	}
	
	
	//创建进程
	pid_t pid=fork();

	if(pid>0){
		//父进程
		while(1)
		{
			printf("这是朕的江山\n");
			sleep(1);
		}
	}else if(pid==0){
		//子进程
		sleep(3);
		printf("我才是真命天子\n");
		kill(getppid(),SIGUSR1);
		while(1)
		{
			printf("现在是我的了\n");
			sleep(1);
		}
	}else{
		perror("pid error");
		return -1;
	}
	return 0;
}

效果图：

1.2 消息队列

msgsnd.c:

#include <myhead.h>

//消息队列结构体
struct msgbuf
{
	long mtype;
	char mtest[1024];
};
//宏表示消息正文的大小
#define MSGSIZE sizeof(struct msgbuf)-sizeof(long)

int main(int argc, const char *argv[])
{
	//创建 key 值
	key_t key=0;
	if((key=ftok("/",'k'))==-1){
		perror("ftok error");
		return -1;
	}
	printf("fork success key=%#x\n",key);
	//根据key值创建消息队列
	int msqid=-1;
	if((msqid=msgget(key,IPC_CREAT|0664))==-1){
		perror("msgget error");
		return -1;
	}
	printf("msgget success msqid=%#x\n",msqid);
	//定义一个消息
	struct msgbuf sbuf;

	while(1)
	{
		//清空正文的容器
		bzero(sbuf.mtest,sizeof(sbuf.mtest));
		
		printf("请输入当前消息的类型:");
		scanf("%ld",&sbuf.mtype);
		getchar();                 //吸收垃圾字符
		printf("请输入消息正文:");
		fgets(sbuf.mtest,sizeof(sbuf.mtest),stdin);
		sbuf.mtest[strlen(sbuf.mtest)-1]='\0';

		//将消息存放到队列中
		msgsnd(msqid,&sbuf,MSGSIZE,0);
		printf("发送成功\n");

		if(strcmp(sbuf.mtest,"quit")==0){
			break;
		}

	}

	return 0;
}

msgrcv.c:

#include <myhead.h>

//消息队列结构体
struct msgbuf
{
	long mtype;
	char mtest[1024];
};
//宏表示消息正文的大小
#define MSGSIZE sizeof(struct msgbuf)-sizeof(long)

int main(int argc, const char *argv[])
{
	//创建 key 值
	key_t key=0;
	if((key=ftok("/",'k'))==-1){
		perror("ftok error");
		return -1;
	}
	printf("fork success key=%#x\n",key);
	//根据key值创建消息队列
	int msqid=-1;
	if((msqid=msgget(key,IPC_CREAT|0664))==-1){
		perror("msgget error");
		return -1;
	}
	printf("msgget success msqid=%#x\n",msqid);
	//定义一个消息
	struct msgbuf rbuf;

	while(1)
	{
		//清空正文的容器
		bzero(rbuf.mtest,sizeof(rbuf.mtest));
	
		//从消息队列中读取一个消息
		msgrcv(msqid,&rbuf,MSGSIZE,0,0);

		printf("收到的消息为:%s\n",rbuf.mtest);

		if(strcmp(rbuf.mtest,"quit")==0){
			break;
		}

	}

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

	return 0;
}

效果图：

作业2：使用消息队列完成两个进程间相互通信

msgsnd.c:

#include <myhead.h>

//定义一个消息类型
struct msgbuf
{
	long mtype;
	char mtest[1024];
};

//宏表示消息正文大小
#define MSGSIZE sizeof(struct msgbuf)-sizeof(long)

/*****************************主程序***********************/
int main(int argc, const char *argv[])
{
	//1、创建key值
	key_t key=0;
	if((key=ftok("/",'k'))==-1){
		perror("ftok error");
		return -1;
	}
	//根据key值创建一个消息队列
	int msqid=-1;
	if((msqid=msgget(key,IPC_CREAT|0664))==-1){
		perror("msgget error");
		return -1;
	}
	//创建一个子进程
	pid_t pid=fork();

	if(pid>0){
		//父进程向消息队列中写入类型为1的消息正文
		//定义一个消息
		struct msgbuf sbuf;
		sbuf.mtype=1;
		while(1)
		{
			//清空容器
			bzero(sbuf.mtest,sizeof(sbuf.mtest));

			printf("发送的消息:");
			fgets(sbuf.mtest,sizeof(sbuf.mtest),stdin);
			sbuf.mtest[strlen(sbuf.mtest)-1]='\0';

			//将消息存放到消息队列
			msgsnd(msqid,&sbuf,MSGSIZE,0);
			printf("发送成功\n");

			if(strcmp(sbuf.mtest,"quit")==0){
				break;
			}
		}
        wait(NULL);	
	}else if(pid==0){
		//子进程从消息队列中取出类型为2的消息正文
		//定义一个消息
		struct msgbuf rbuf;

		while(1)
		{
			//清空容器
			bzero(rbuf.mtest,sizeof(rbuf.mtest));

			//从消息队列中读取类型为2的消息正文
			msgrcv(msqid,&rbuf,MSGSIZE,2,0);

			printf("收到的消息为:%s\n",rbuf.mtest);
			if(strcmp(rbuf.mtest,"quit")==0){
				break;
			}
		}
        exit(EXIT_SUCCESS);
	}else{
		perror("fork error");
		return -1;
	}

	return 0;
}

msgrcv.c:

#include <myhead.h>

//定义一个消息类型
struct msgbuf
{
	long mtype;
	char mtest[1024];
};

//宏表示消息正文大小
#define MSGSIZE sizeof(struct msgbuf)-sizeof(long)

/*****************************主程序***********************/
int main(int argc, const char *argv[])
{
	//1、创建key值
	key_t key=0;
	if((key=ftok("/",'k'))==-1){
		perror("ftok error");
		return -1;
	}
	//根据key值创建一个消息队列
	int msqid=-1;
	if((msqid=msgget(key,IPC_CREAT|0664))==-1){
		perror("msgget error");
		return -1;
	}
	//创建一个子进程
	pid_t pid=fork();

	if(pid>0){
		//父进程从消息队列中取出类型为1的消息正文
		//定义一个消息
		struct msgbuf rbuf;

		while(1)
		{
			//清空容器
			bzero(rbuf.mtest,sizeof(rbuf.mtest));

			//从消息队列中读取类型为1的消息正文
			msgrcv(msqid,&rbuf,MSGSIZE,1,0);

			printf("收到的消息为:%s\n",rbuf.mtest);
			if(strcmp(rbuf.mtest,"quit")==0){
				break;
			}
		}
        wait(NULL);
	}else if(pid==0){
		//子进程向消息队列中写入类型为2的消息正文
		//定义一个消息
		struct msgbuf sbuf;
		sbuf.mtype=2;
		while(1)
		{
			//清空容器
			bzero(sbuf.mtest,sizeof(sbuf.mtest));

			printf("发送的消息:");
			fgets(sbuf.mtest,sizeof(sbuf.mtest),stdin);
			sbuf.mtest[strlen(sbuf.mtest)-1]='\0';

			//将消息存放到消息队列
			msgsnd(msqid,&sbuf,MSGSIZE,0);
			printf("发送成功\n");

			if(strcmp(sbuf.mtest,"quit")==0){
				break;
			}
		}
        exit(EXIT_SUCCESS);
	}else{
		perror("fork error");
		return -1;
	}

	return 0;
}

效果图：

作业3：思维导图

FS223107
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux进程通信之SystemV消息队列
03-03
SystemV消息队列是OpenGroup...当向一个空消息队列中写入一个消息时，POSIX消息队列允许产生一个信号或启动一个线程，SystemV消息队列不提供类似的机制。系统内核都会为每一个SystemV消息队列维护一个信息结构，在Linux
进程通信（共享内存消息队列）实例
08-14
父子进程之间通过消息队列来传递消息。 父进程需要维护一个本地数据库（格式与共享数据库相同），当生成一个消息时，父进程要同步更新本地数据库。子进程在处理消息时，根据消息的内容来对共享数据库进行更新
[Linux]-进程间通信之消息队列
levi的博客
06-22 2080
之前我们使用过的管道比较适用于较少进程之间的通信，那么如果想要实现多个进程之前的通信的话，我们需要使用消息队列消息队列具有如下特点1.消息队列是消息的链表，存放于内存中，内核维护消息队列2.消息队列中的消息是有类型的3.消息队列中的消息是有格式的4.消息队列可实现消息随机查询，并且不一定要遵循先进先出的顺序，而是每个进程可以按照感兴趣的类型进行读取5.与管道相同，读出数据后，消息队列对应数据会被删除6.每个管道都有消息队列标识符，在整个系统中是唯一的7.消息队列允许。
Linux开发(八)：多进程通信与同步---消息队列
王木木
03-09 1583
进程用户空间是相互独立的，一般而言是不能相互访问的。但很多情况下进程间需要互相通信，来完成系统的某项功能。进程通过与内核及其它进程之间的互相通信来协调它们的行为。 一、消息队列 消息队列实质上就是一个链表,该链表是由系统内核维护，读取消息时，不一定遵循先进先出原则, 也可以按消息的类型字段进行读取。 1、获取key值 Linux系统建立IPC通讯（如消息队列、共享内存时）必须指定一个ID值。通常情况下，该id值通过ftok函数得到。 key_t ftok( char * fname, int i
利用Linux的消息队列通信机制实现两个线程间的通信
一只博客
08-05 5960
3）利用Linux的消息队列通信机制实现两个线程间的通信 编写程序创建三个线程：sender1线程、sender2线程和receiver线程，三个线程的功能描述如下： ①sender1线程：运行函数sender1()，它创建一个消息队列，然后等待用户通过终端输入一串字符，并将这串字符通过消息队列发给receiver线程;可循环发送多个消息，直到用户输入“exit”为...
进程间通信：消息队列概念及代码
Tyler_Zx的博客
03-10 3711
前言 接下讨论的IPC机制，它们最初由System V版本的Unix引入。由于这些机制都出现在同一个版本中并且有着相似的编程接口，所以它们被称为System V IPC机制。接下来的内容包括： 信号量：用于管理对资源的访问。 共享内存：用于在程序之间高效地共享数据。 消息队列：在程序之间传递数据。 消息队列 消息队列与命名管道有许多相似之处，但少了在打开和关闭管道方面的复杂性。但...
利用消息队列实现两个进程之间的通信
weixin_44651073的博客
03-30 2251
要求使用消息队列，实现两个进程之间的通信。 写端程序分析： #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> #include <stdio.h> #include <strings.h> #include <string.h> #include <stdlib.h> //写入数据的及结构体 struct msgbuf{ long...
Linux 进程间通信：管道、共享内存、消息队列、信号量
凌桓丶的博客
04-13 2643
进程间通信 管道 共享内存 消息队列 信号量 进程间通信 https://blog.csdn.net/qq_35423154/article/details/105294963 在之前的一篇博客中讲过， # <h1 id="2"> 管道</h1> # <h1 id="3"> 共享内存</h1> # <h1 id="4"&gt...
Linux进程间通信四 Posix 消息队列简介与示例
fuyuande的博客
07-04 4637
1. 读取的时候，buffer要足够大。 2. 需要手动mount看数据。 3. 优先级队列，可以获取优先级 参考文档 https://www.man7.org/linux/man-pages/man7/mq_overview.7.html
Linux进程间通信——消息队列
Biao
04-24 4988
一、什么是消息队列 消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法。 每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据结构。我们可以通过发送消息来避免命名管道的同步和阻塞问题。但是消息队列与命名管道一样，每个数据块都有一个最大长度的限制。 Linux用宏MSGMAX和MSGMNB来限制一条消息的最大长度和一个队列的最大长度。 二、在Li...
UCOS-II任务间通信（信号量、邮箱、消息队列）
_CJM的博客
04-20 8163
保护任务之间的共享数据和提供任务之间的通讯方法： 利用宏OS_ENTER_CRITICAL()和OS_EXIT_CRITICAL()来关闭和打开中断，这可以用于多任务或者任务和ISR共享某些数据时可以采用这种方法。 利用OSSchedLock()和OSSchedUnlock()对uC/OS-II中的任务调度器上锁和开锁。 利用信号量、邮箱和消息队列。 　　一个任务或者中断服务子程序
Linux编程学习笔记：进程间通信（消息队列和信号量）
a568713197的博客
02-02 1653
一、消息队列     定义         Unix早期通信机制之一的信号能够传送的信息量有限，管道则只能传送无格式的字节流，这给程序开发带来了不便，消息队列（也叫作报文队列）则客服了这些缺点         消息队列就是一个消息的链表，可以把消息看做一个记录，具有特定的格式，进程可以向中按照一定的规则添加新消息；另一些进程则可以从消息队列中读走消息     分类：POSIX消息队列和系统...
linux_process_communication.rar_linux 进程通信_消息队列 _进程通信
09-20
本资源中含有有关LINUX进程通信的一些文章，从详细说明了信号量、管道以及消息队列等方式介绍。
STM32搭载RTOS实现任务+消息队列+串口通信完整项目代码
07-25
本项目在cortex-m3 STM32奋斗开发板V5上成功运行.平台:KEIL4 搭载FreeRTOS系统，任务一向消息队列填充数字，任务二从消息队列提取数据并发送...对于STM32和FreeRTOS初学者以及想了解RTOS的任务机制与消息队列的好例程。
进程间通信之消息队列 ( message queue ）——完整代码
01-24
进程间通信之消息队列 ( message queue ） 消息队列是消息的链表,具有特定的格式,并由消息队列标识符标识. 七种进程间通信方式： 一.无名管道（ pipe ） 二.有名管道（ fifo ） 三.共享内存 ( shared memory ) 四....
力扣2187.完成旅途的最少时间
最新发布
Pisasama的博客
06-12 423
二分答案。
指针和数组
2301_77634163的博客
06-10 462
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
C++的算法：Kosaraju算法与Tarjan算法
全栈工程师Linda的博客
06-10 480
C++的算法：Kosaraju算法与Tarjan算法
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 732
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
进程间通信，共享内存，posix信号量,消息队列
05-23
消息队列是一种通信机制，它允许进程之间通过发送消息实现通信。多个进程可以通过一个公共的消息队列来传递消息，从而实现进程间通信和同步。 以上这些IPC方式都可以用于进程间通信和协调，但在不同情况下，选择...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值