Linux练习_进程间信号练习

最新推荐文章于 2023-03-12 21:03:00 发布
最新推荐文章于 2023-03-12 21:03:00 发布
阅读量439 收藏 2
点赞数 2
分类专栏： Linux练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44342705/article/details/116941382
版权

进程练习

例题1

  • 要求：创建一对父子进程，子进程通过ctrl+c结束，父进程回收完子进程资源后，再次按ctrl+c结束父进程
  • 分析：父进程先忽略信号，接收到子进程结束的信号后再打开接受信号
/*
 * signal.c
 *要求：子进程通过ctrl+c结束，父进程回收完子进程资源后，再次按ctrl+c结束父进程

 * 
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <wait.h>

void sig_handler(int signum)
{
	if(signum==SIGINT){
		printf("回收进程\n");
		exit(0);
	}
}

int main(int argc, char **argv)
{
	pid_t pid;
	pid = fork();
	if(pid<0){perror("fork error");exit(1);}
	else if(pid==0){ //child process
		printf("pid: %d,ppid: %d\n", getpid(),getppid());
		while(1)signal(SIGINT, sig_handler); //子进程等待ctrl+c信号
	}
	else {
		signal(SIGINT,SIG_IGN); //屏蔽ctrl+c信号
		wait(0); //等待子线程结束
		while(1)signal(SIGINT, sig_handler); //父进程等待ctrl+c信号
	}
}

例题2

描述：

  • 创建2个.c文件，每个.c文件中各有一对父子进程，这四个进程分别称为A,a,B,b进程
    要求：
  • a进程通过ctrl+c结束后，向b进程发送信号，表示a结束;
  • b进程接收到a的信号后立即结束;
  • B进程接收到b进程结束信号后，回收b资源，并且向A发送信号;
  • A进程接收到B进程的信号后，回收a进程的资源，然后A结束。
    所有过程要求有完善的printf提示
    关于AaBb4个进程，若有数据交互情况，使用文件IO实现。
  1. 使用C标准文件IO编写
  • A进程程序：
/*
 * A进程.c
 */

#include <stdio.h>
#include <signal.h>
#include <wait.h>
#include <unistd.h>
#include <stdlib.h>

int Apid=0;
int bpid=0;

void sig_handler(int signum)
{
	if(signum==SIGINT){
		kill(bpid,SIGINT);
		printf("a end\n");
		exit(0);
	}
	if(signum==SIGQUIT){
		wait(0);
		printf("all end\n");
		exit(0);
	}
}

int main(int argc, char **argv)
{
	int res = fork();
	if(res>0){
		//A
		Apid = getpid();
		signal(SIGINT,SIG_IGN);
		signal(SIGQUIT,sig_handler);
		 FILE* fp = fopen("./A.txt","w");
		 fwrite(&Apid,4,1,fp);
		 fclose(fp);
	}
	else {
		//a
		signal(SIGINT,sig_handler);
		FILE* fp=0;
		while(fp==0){//手动写同步逻辑
			fp = fopen("./b.txt","r");
		}
		fread(&bpid,4,1,fp);
		fclose(fp);
	}
	while(1);
	return 0;
}
  • B进程程序：
/*
 * B进程.c
 * 
 */

#include <stdio.h>
#include <signal.h>
#include <wait.h>
#include <unistd.h>
#include <stdlib.h>

int bpid=0;
int Apid=0;

void sig_handler(int signum)
{
	if(signum==SIGINT){
		printf("b end\n");
		exit(0);
	}
	if(signum==SIGCHLD){
		FILE* fp = fopen("./A.txt","r");
		fread(&Apid,4,1,fp);
		fclose(fp);
		kill(Apid,SIGQUIT);
		printf("B end\n");
		wait(0);
		exit(0);
	}
}

int main(int argc, char **argv)
{
	int res = fork();
	if(res>0){
		//B
		signal(SIGCHLD,sig_handler);
	}
	else{
		//b
		signal(SIGINT,sig_handler);
		bpid = getpid();
		FILE* fp = fopen("./b.txt","w");
		fwrite(&bpid,4,1,fp);
		fclose(fp);
	 }
	while(1);
	return 0;
}
  1. 使用FIFO命名管道

  • 信号框图：在这里插入图片描述

  • A进程程序：

/*
 * A进程.c
 * 
 * 
 */
#include <stdio.h>
#include <signal.h>
#include <wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h> 

int Apid=0;
int bpid=0;
int fifofdrd,fifofdwr;

void sig_handler(int signum)
{
		if(signum==SIGINT){
		kill(bpid,SIGINT);
		printf("a end\n");
		exit(0);
	}
	if(signum==SIGQUIT){
		wait(0);
		remove("my_fifob");
		remove("my_fifoA");
		printf("all end\n");
		exit(0);
	}
}

int main(int argc, char **argv)
{
	mkfifo("my_fifob",0666);
	mkfifo("my_fifoA",0666);
	fifofdrd = open("my_fifob",O_RDONLY);
	fifofdwr = open("my_fifoA",O_WRONLY);
	
	int res = fork();
	if(res>0){
		//A
		Apid = getpid();
		signal(SIGINT,SIG_IGN);
		signal(SIGQUIT,sig_handler);
		write(fifofdwr,&Apid,sizeof(int));
		close(fifofdwr);
	}
	else {
		//a
		signal(SIGINT,sig_handler);
		read(fifofdrd,&bpid,sizeof(int));
		close(fifofdrd);
	}
	while(1);
	return 0;
}
  • B进程程序
/*
 * B进程.c
 * 
 */

#include <stdio.h>
#include <signal.h>
#include <wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h> 

int bpid=0;
int Apid=0;
int fifofdrd,fifofdwr;

void sig_handler(int signum)
{
	if(signum==SIGINT){
		printf("b end\n");
		exit(0);
	}
	if(signum==SIGCHLD){
		read(fifofdrd,&Apid,sizeof(int));
		close(fifofdrd);
		kill(Apid,SIGQUIT);
		printf("B end\n");
		wait(0);
		exit(0);
	}
}

int main(int argc, char **argv)
{
	
	mkfifo("my_fifob",0666);
	mkfifo("my_fifoA",0666);
	fifofdwr = open("my_fifob",O_WRONLY);
	fifofdrd = open("my_fifoA",O_RDONLY);
	
	int res = fork();
	if(res>0){
		//B
		signal(SIGCHLD,sig_handler);
	}
	else{
		//b
		signal(SIGINT,sig_handler);
		bpid = getpid();
		write(fifofdwr,&bpid,sizeof(int));
		close(fifofdwr);
	 }
	while(1);
	return 0;
}
  1. alarm
    要求：使用alarm，每2秒打印输出
    框图：在这里插入图片描述

代码：

/*
 * alarm信号.c
 * 
 */
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int signum)
{
	if(signum==SIGALRM){
		printf("2s end\n");
		alarm(2);
	}
}

int main(int argc, char **argv)
{
	signal(SIGALRM,handler);
	alarm(2);
	while(1);
	return 0;
}
  1. pipe
  • 要求：
    • 创建一个子进程，在其中获取当前工作路径并打印。
    • 运用获取的路径，在路径下创建文件1.txt
    • 使用信号SIGALRM间隔1秒向文件1.txt写入"Hello"
    • 按下ctrl+c结束子进程。
    • 父进程打印"Child process end"结束。
/*
 * pipe.c
 * 创建一个子进程，在其中获取当前工作路径并打印。
 * 运用获取的路径，在路径下创建文件1.txt
 * 使用信号SIGALRM间隔1秒向文件1.txt写入"Hello"
 * 按下ctrl+c结束子进程。
 * 父进程打印"Child process end"结束。
 */


#include <stdio.h>
#include <wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

FILE* fp;
	
void sig_handler(int signum)
{
	if(signum==SIGALRM)
	{
		printf("Hello\n");
		fprintf(fp,"Hello\n");
		alarm(1);
	}
	
	if(signum==SIGINT)
	{
		fclose(fp);
		exit(0);
	}
}

int main(int argc, char **argv)
{
	pid_t cpid = fork();
	if(cpid<0){perror("child process error");exit(1);}
	
	if(cpid==0){
		printf("Child process start\n");
		fp=popen("pwd","r");
		char path[127];
		fgets(path,sizeof(path),fp);
		printf("%s",path);
		path[strlen(path)-1]='\0';
		pclose(fp);
		
		strcat(path,"/1.txt");
		printf("%s",path);
		fp=fopen(path,"w");
		alarm(1);
		while(1){
			signal(SIGALRM,sig_handler);
			signal(SIGINT,sig_handler);
		}	
	}
	if(cpid>0){
		signal(SIGINT,SIG_IGN);
		wait(0);
		printf("Child process end\n");
		fclose(fp);
		exit(0);
	}
	
	return 0;
}

输出：

pi@raspberrypi:~/haitong-learning/Linux/homework/管道练习 $ ./pipe 
Child process start
/home/pi/haitong-learning/Linux/homework/管道练习
/home/pi/haitong-learning/Linux/homework/管道练习/1.txtHello
Hello
Hello
Hello
Hello
^C
Child process end
pi@raspberrypi:~/haitong-learning/Linux/homework/管道练习 $
  1. FIFO
  • 要求：
    • 实现两个程序mysignal，mycontrol
    • mycontrol给mysignal发送SIGINT信号，控制mysignal在屏幕打印"Hello"字符串
    • 在mysignal发送SIGQUIT(按ctl+)则两个程序都关闭。
  • 分析：使用FIFO进行进程间的通信，获取对方的PID，然后使用kill传送信号
  • 代码：
    mysignal程序：
/*
 * mysignal.c
 * 
 */

 #include <sys/stat.h> //包含mkfifo
 #include <sys/types.h> //pid_t
 #include <fcntl.h> //包含O_REONLY
 #include <signal.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>

int sigpid,ctlpid;
int fdwr,fdrd;
char* toctl = "toctl_fifo";
char* tosig = "tosig_fifo";

void sig_handler(int signum)
{
	if(signum==SIGINT){
		printf("Hello\n");
	}
	if(signum==SIGQUIT){
		kill(ctlpid,SIGQUIT);
		printf("\nmysignal process end\n");
		remove(toctl);
		remove(tosig);
		exit(0);
	}
}

int main(int argc, char **argv)
{
	printf("按ctl+\\退出\n");
	
	int sigpid = getpid();
	printf("sigpid:%d\n",sigpid);
	
	mkfifo(toctl,0666);
	fdwr = open(toctl,O_WRONLY);
	write(fdwr,&sigpid,sizeof(int));
	close(fdwr);
	
	mkfifo(tosig,0666);
	fdrd = open(tosig,O_RDONLY);
	read(fdrd,&ctlpid,sizeof(int));
	printf("ctlpid:%d\n",ctlpid);
	close(fdrd);
	
	while(1){
		signal(SIGQUIT,sig_handler);
		signal(SIGINT,sig_handler);
	}
	return 0;
}

mycontrol程序：

/*
 * mycontrol.c
 * 
 */


 #include <sys/stat.h> //包含mkfifo
 #include <sys/types.h> //pid_t
 #include <fcntl.h> //包含O_REONLY
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>

int ctlpid,sigpid;
int fdrd,fdwr;
char* toctl = "toctl_fifo";
char* tosig = "tosig_fifo";

void sig_handler(int signum)
{
	if(signum==SIGINT){
		kill(sigpid,SIGINT);
	}
	if(signum==SIGQUIT){
		printf("\nmycontrol process end\n");
		exit(0);
	}
}

int main(int argc, char **argv)
{
	printf("按ctl+c在mysignal打印hello\n");
	
	int ctlpid = getpid();
	printf("ctlpid:%d\n",ctlpid);
	
	mkfifo(toctl,0666);
	fdrd = open(toctl,O_RDONLY);
	read(fdrd,&sigpid,sizeof(int));
	printf("sigpid:%d\n",sigpid);
	close(fdrd);
	
	mkfifo(tosig,0666);
	fdwr = open(tosig,O_WRONLY);
	write(fdwr,&ctlpid,sizeof(int));
	close(fdwr);
	
	while(1){
		signal(SIGINT,sig_handler);
		signal(SIGQUIT,sig_handler);
	}
	return 0;
}

输出：

mycontrol程序：
pi@raspberrypi:~/haitong-learning/Linux/homework/管道练习 $ ./mycontrol 
按ctl+c在mysignal打印hello
ctlpid:1932
sigpid:1930
^C^C^C^C
mycontrol process end

mysignal程序：
pi@raspberrypi:~/haitong-learning/Linux/homework/管道练习 $ ./mysignal 
按ctl+\退出
sigpid:1930
ctlpid:1932
Hello
Hello
Hello
Hello
^\
mysignal process end
Leslie X徐
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统实验报告(LINUX进程间通信)
12-30
操作系统实验报告(LINUX进程间通信)
进程间通信2
CltCj的博客
05-12 289
进程间通信（面试常考）五、信号5.1 信号的机制5.2 信号的状态5.3 信号的特质5.4 阻塞信号集和未决信号集5.5 信号的四要素六、信号相关函数6.1 signal函数6.2 kill函数/命令6.3 abort函数raise函数6.4 alarm函数6.5 setitimer函数七、信号集相关7.1 未决信号集和阻塞信号集的关系7.2 信号集相关函数八、信号捕捉函数SIGCHLD信号总结 五、信号   信号是信息的载体，Linux/UNIX 环境下，古老、经典的通信方式， 现下依然是主要的通信手段
进程信号
weixin_43831728的博客
03-05 420
进程信号 本节主要内容 掌握Linux信号的基本概念 掌握信号产生的一般方式 理解信号递达和阻塞的概念，原理。 掌握信号捕捉的一般方式。 重新了解可重入函数的概念。 信号主要会涉及到： 信号的概念 信号的产生 信号的注册 信号的注销 信号的捕捉处理 自定义信号处理函数 ...
操作系统实验题目之进程控制(含c语言代码)
qq_41620273的博客
12-25 4118
① 编写一段程序，实现进程的软中断通信。 要求：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill()向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止： Child Processll is Killed by Parent! Child Processl2 is Killed by Parent! 父进程等待两个子进程终止后，输出如下的信息后终止 Parent Process is
操作系统 实验四 进程间通信实验
weixin_57836618的博客
11-26 7438
实验四 进程间通信实验 一、实验目的 1、了解什么是信号。 2、熟悉LINUX系统中进程之间软中断通信的基本原理。 3、理解进程的同步关系。 4、了解什么是管道。 5、熟悉UNIX/LINUX支持的管道通信方式。 二、实验内容 1、编写一段程序，使用系统调用fork( )创建两个子进程，再用系统调用signal( )让父进 程捕捉键盘上来的中断信号（即按ctrl+c键），当捕捉到中断信号后，父进程用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止：...
【Linux练习生】进程信号（深度理解）
平淡中造就不平凡
07-23 590
前面我们介绍的进程间通信，都是常规状态下的工作模式。对于异常情况下的工作模式，就需要用「信号」的方式来通知进程。
Linux系统编程之线程同步
05-08
实际上，不仅线程间需要同步，进程间、信号间等等都需要同步机制。 因此，所有“多个控制流，共同操作一个共享资源”的情况，都需要同步。 数据混乱原因： 1. 资源共享（独享资源则不会） 2. 调度随机（意味着...
操作系统实验二 进程通信机制的应用
05-14
操作系统实验二:进程通信机制的应用实验报告。加深对于进程并发执行概念的理解。...掌握进程控制的方法,了解父子进程间的控制和协作关系。练习 Linux 系统中进/线程创建与控制有关的系统调用的编程和调试技术。
linux系统编程之线程.zip
05-05
(两个进程间，线程ID允许相同) 注意：不应使用全局变量 pthread_t tid，在子线程中通过pthread_create传出参数来获取线程ID，而应使用pthread_self。 pthread_create函数 创建一个新线程。 其作用，对应进程中fork...
操作系统实验一 进程控制
05-14
操作系统进程控制实验源码与完整实验报告。加深对于进程并发执行概念的理解。...掌握进程控制的方法,了解父子进程间的控制和协作关系。练习 Linux 系统中进/线程创建与控制有关的系统调用的编程和调试技术。
Linux 练习十 （IPC 信号）
to_upper的博客
03-12 379
进程间通信——信号
Linux C编程之进程间通信
qq_53003541的博客
08-06 966
linux进程通信
Linux进程间的通信——信号处理
MR_Allen_Lwx的博客
10-15 658
1、实现两个程序mysignal、mycontrl，mycontrl给mysignal发送SIGINT信号， 控制mysignal是否在屏幕打印“hello”字符串。
实现两个程序mysignal、mycontrl，mycontrl给mysignal发送SIGINT信号，控制mysignal是否在屏幕打印“hello”字符串。
HelloNiGeSB的博客
07-10 1523
int status = 0; void catch_Signal(int Sign) { ` switch (Sign) { case SIGINT: if (status == 0) status = 1; else status = 0; break; } } int singnal1(int signo, void (*func)(i
linux 练习六 信号的发送与信号处理
hexiechina2010的专栏
12-02 593
题目：实现两个程序mysignal、mycontrl，mycontrl给mysignal发送SIGINT信号，控制mysignal是否在屏幕打印“hello”字符串。 //mycontrol.c #include #include #include #include #include int main(int argc , char *argv[]) { pid_t
Linux--信号练习
小宣子
04-07 269
信号的响应有三种方式： 响应方式： 1、缺省 2、忽略（有些信号不能被忽略，SIGKILL 、SIGSTOP） 3、捕获信号（SIGKILL 、SIGSTOP 也不能被捕获） 安装信号 我们就收到信号有相应的处理，但首先我们要先有这个信号才行，所以首先要安装信号 下面来用一下看看： 我将Ctrl+c的信号SIGINT进行设置一下，我们按Ctrl+c执行我们自己写的函数，...
linux信号处理--通过发送信号控制进程
weixin_34348111的博客
05-30 263
要求： 实现两个程序mysignal、mycontrl, mycontrl给mysignal发送SIGINT信号，控制mysiganl是否在屏幕打印"hello,world"字符串. //makefile .SUFFIXES: .c .o CC=gcc SRCS1=mysignal.c SRCS2=mycontrol.c ...
linux 信号处理实验,linux下信号处理
weixin_36078306的博客
05-14 195
前言：这一章我们讨论一下Linux下的信号处理函数。Linux下的信号处理函数：信号的产生信号的处理其它信号函数一个实例1.信号的产生Linux下的信号可以类比于DOS下的INT或者是Windows下的事件。在有一个信号发生时候相信的信号就会发送给相应的进程。在Linux下的信号有以下几个。 我们使用 kill -l 命令可以得到以下的输出结果：1) SIGHUP 2) SIGINT 3) SIG...
linux中信号处理,linux下的信号处理实例
weixin_39637921的博客
05-14 125
本文关键字： 信号处理，linux信号通信该实例首先把SIGQUIT、SIGINT两个信号加入信号集，然后将该信号集设为阻塞状态，并进入用户输入状态。用户只需按任意键，就可以立刻将信号集设置为非阻塞状态，再对这两个信号分别操作，其中SIGQUIT执行默认操作，而SIGINT执行用户自定义函数的操作。源代码如下：/* sigset.c */#include #include #include #in...
linux进程间通信信号量
最新发布
03-16
Linux进程间通信中的信号量是一种同步机制，用于协调多个进程之间的共享资源访问。信号量可以用于实现进程间的互斥、同步和通信等功能。 在Linux中，信号量是由一个整型变量和一组操作函数组成的。进程可以通过操作函数对信号量进行P操作（申请资源）和V操作（释放资源），从而实现对共享资源的控制。 信号量的使用需要注意一些问题，如信号量的初始化、使用时的同步和互斥等。在实际应用中，可以根据具体的需求选择不同的信号量类型和操作函数，以实现更加灵活和高效的进程间通信。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值