操作系统实验：信号机制

【实验目的】

1、了解什么是信号。

2、熟悉 LINUX 系统中进程之间软中断通信的基本原理。

实验要求：了解和熟悉 LINUX 支持的信号机制。

【实验内容】

1、编写一段程序，使用系统调用 fork( )创建两个子进程，再用系统调用 signal( )让父进程捕捉键盘上来的中断信号（即按 ctrl+c 键），当捕捉到中断信号后，父进程用系统调用 kill( )向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止：

Child process 1 is killed by parent!

Child process 2 is killed by parent!

父进程等待两个子进程终止后，输出以下信息后终止：

Parent process is killed!

实验要求：

⑴、运行程序并分析结果。

⑵、如果把 signal(SIGINT,stop)放在①号和②号位置，结果会怎样并分析原因。

⑶、该程序段前面部分用了两个 wait(0),为什么？

⑷、该程序段中每个进程退出时都用了语句 exit(0),为什么？

3、司机售票员问题（选做题）

编程用 fork()创建一个子进程代表售票员，司机在父进程中，再用系统调用 signal()让父进程（司机）捕捉来自子进程（售票员）发出的中断信号，让子进程（售票员）捕捉来自（司机）发出的中断信号，以实现进程间的同步运行。

【实验环境】（含主要设计设备、器材、软件等）

Pc电脑一台，虚拟机下Linux系统

【实验步骤、过程】（含原理图、流程图、关键代码，或实验过程中的记录、数据等）

1.首先定义两个函数 waiting() 和 stop()。waiting() 函数会一直等待，直到 wait_mark 变为0。stop() 函数将 wait_mark 设置为0。在主函数中，首先为 SIGINT 信号（ctrl+c）设置了一个处理函数 stop()。接着创建了两个子进程 p1 和 p2。如果 p1 和 p2 的创建成功，那么父进程将 wait_mark 设置为1，并调用 waiting() 函数等待。当 wait_mark 变为0时，父进程将向 p1 和 p2 发送信号10和12，然后等待两个子进程结束。最后，打印出 “parent process is killed!” 并退出。对于 p2，它将 wait_mark 设置为1，并为信号 12 设置处理函数 stop()。然后，它调用 waiting() 函数等待。当 wait_mark 变为0时，它将打印出 “child process 2 is killed by parent!” 并退出。对于 p1，它的行为与 p2 类似，只是它为信号 10 设置了处理函数 stop()，并在 wait_mark 变为0时打印出 “child process 1 is killed by parent!”。

流程图：

 

#include<stdio.h>
#include<signal.h>
#include<unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int wait_mark;
void waiting()
{
	while(wait_mark != 0) ;
}
void stop()
{
	wait_mark=0;
}
int main()
{
	int p1, p2;
    signal(SIGINT,stop);
	while((p1=fork())==-1);
	if(p1>0)
	{ ①
		signal(SIGINT,stop);
		while((p2=fork())==-1);
		if(p2>0)
		{ ②
			wait_mark=1;
			waiting(0);
			kill(p1,10);
			kill(p2,12);
			wait(0);
			wait(0);
			printf("parent process is killed!\n");
			exit(0);
	     }
	    else
		{
			wait_mark=1;
			signal(12,stop);
			waiting();
			lockf(1,1,0);
			printf("child process 2 is killed by parent!\n");
			lockf(1,0,0);
			exit(0);
		}
	}
	else
	{
		 wait_mark=1;
		 signal(10,stop);
		 waiting();
		 lockf(1,1,0);
		 printf("child process 1 is killed by parent!\n");
		 lockf(1,0,0);
		 exit(0);
	}
}

2.定义IntDelete函数，在接收到中断信号（SIGINT）时被调用，向两个子进程发送信号（SIGUSR1和SIGUSR2），然后将EndFlag设置为1。Int1和Int2函数打印输出语句。在主函数中，忽略SIGINT和SIGQUIT。创建子进程p1。对于p1，设置一个信号处理函数，当接收到SIGUSR1时，调用Int1函数。进入暂停状态，等待接收信号，然后退出进程。创建子进程p2，对于p2，操作与p1类似，当接收到SIGUSR2时，调用Int2函数。当父进程接收到中断信号（SIGINT）时，调用IntDelete函数。然后等待两个子进程结束。打印一条消息，然后退出进程。

流程图：

#include<stdio.h>
#include<signal.h>
#include<unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int pid1, pid2,EndFlag=0,exitcode;
void IntDelete()
{
	kill(pid1,10);
	kill(pid2,12);
	EndFlag=1;
}
void Int1()
{
	printf("child process 1 is killed by parent !\n");
	exit(0);
}
void Int2()
{
	printf("child process 2 is killed by parent !\n");
	exit(0);
}
int main()
{ 
	signal(SIGINT,SIG_IGN);
	signal(SIGQUIT,SIG_IGN);
	while((pid1=fork())==-1);
	if(pid1==0)
	{ 
		signal(SIGUSR1,Int1);
		signal(SIGQUIT,SIG_IGN);
		pause();
		exit(0);
	}
	else
	{
		while((pid2=fork())==-1);
		if(pid2==0)
		{
			signal(SIGUSR2,Int2);
			signal(SIGQUIT,SIG_IGN);
			pause();
			exit(0);
	 	}
	 	else
	 	{
		 	signal(SIGINT,IntDelete);
			waitpid(-1,&exitcode,0);
			printf("parent process is killed \n");
		 	exit(0);
		} 
	}
}

3.（选做题）：创建两个进程：父进程代表司机，子进程代表售票员。售票员通过捕获SIGINT信号停止售票，并发送信号SIGUSR1通知司机，司机通过捕获SIGUSR1信号开始驾驶，并在行驶一定时间后停车，并发送信号SIGUSR2通知售票员开始售票。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/wait.h>
int pid;
void saler(int signum)
{
    if (signum == SIGINT)
    {
        printf("Saler stopping ticket sales\n");
        kill(getppid(), SIGUSR1);
    }
    if (signum == SIGUSR2)
    {
    	printf("Saler starts selling tickets\n");
    	exit(0);
	}
}
void driver(int signum)
{
    if (signum == SIGUSR1)
    {
        printf("Driver starts driving\n");
        sleep(5);
       	printf("stop the bus\n");
        kill(pid,SIGUSR2);
    }
}

int main()
{
	signal(SIGQUIT, SIG_IGN);
	signal(SIGTSTP, SIG_IGN);
    if ((pid = fork()) == -1)
    {
        printf("Fork failed\n");
       	return -1;
    }
    if (pid > 0)
    {
        // driver
        signal(SIGINT, SIG_IGN);
        signal(SIGUSR1, driver);
        wait(0);
    }
    else
    {
    	printf("Saler is selling\n");	
        signal(SIGINT, saler);
        signal(SIGUSR2,saler);
        while(1)
		{
           pause();
		}
    }

    return 0;
}

【实验结果或总结】（对实验结果进行相应分析，或总结实验的心得体会，并提出实验的改进意见）

1.(1)刚开始父进程，p1进程，p2都在waiting（）中等待，当按下ctrl+c时，父进程，p1进程，p2进程三个进程都接受到了信号，都会执行stop函数，从而把3个进程内的wait_mark置为0，输出语句。程序运行多次，p1，p2的执行顺序不定，父进程最后输出。

(2)signal(SIGINT,stop)放在①号位置时，子进程p1监听不到signal(SIGINT,stop)，而ctrl+c本身就有一个中断进程的作用，这时候如果按下了ctrl+c，p1直接被中断，不再等待，也不执行子进程之后的代码。

执行结果：

signal(SIGINT,stop)放在②号位置时，子进程p1、p2监听不到signal(SIGINT,stop)，而ctrl+c本身就有一个中断进程的作用，这时候如果按下了ctrl+c，p1、p2直接被中断，不再等待，也不执行之后的代码。

执行结果：

signal(SIGINT,stop)放在①和②号位置时，结果和原因同放在①号位置一样。

执行结果：

(3)使用两个wait(0)是为了确保父进程能够正确地回收两个子进程的资源，避免出现僵尸进程的情况。如果只使用一个wait(0)，那么父进程只会等待一个子进程结束，另一个子进程可能还在运行或已经终止但没有被回收，这样就会造成资源的浪费和系统的不稳定。因此，为了保证父进程能够等待所有的子进程都结束，需要使用和子进程数量相同的wait(0)函数。

(4)用exit(0)的作用是使父进程、子进程实现自我终止，正常退出此次操作。

2.当按下ctrl+c时，父进程执行IntDelete函数，通过kill函数分别将信号1和信号2传递给两个子进程，子进程接受信号执行Int函数，输出语句。程序运行多次，进程的执行顺序不定。

3.刚开始售票员在售票中，当按下ctrl+c时，子进程（售票员）执行saler函数停止售票，并向父进程（司机）发送SIGUSR1，司机开始开车，5s后司机停车，并向子进程发送了SIGUSR2，子进程接受信号后再次执行saler函数开始售票。