操作系统二Word格式.doc
《操作系统二Word格式.doc》由会员分享，可在线阅读，更多相关《操作系统二Word格式.doc（8页珍藏版）》请在冰点文库上搜索。
执行时屏幕出现的现象，并分析原因。
如果在程序中使用调用lockf（）来给每一个子进程加锁，可以实现进程之间的互斥，观
察并分析出现的现象。
（3）①编写一段程序，使其现实进程的软中断通信。
要求：
使用系统调用fork（）创建两个子进程，再用系统调用signal（）让父进程捕捉键盘上来的中断信号（即按DEL键）；
当捕捉到中断信号后，父进程用系统调用Kill（）向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：
ChildProcessllisKilledbyParent!
ChildProcessl2isKilledbyParent!
父进程等待两个子进程终止后，输出如下的信息后终止
ParentProcessisKilled!
②在上面的程序中增加语句signal（SIGNAL,SIG-IGN）和signal（SIGQUIT,SIG-IGN）,观察执行结果，并分析原因。
（4）进程的管道通信
编制一段程序，实现进程的管理通信。
使用系统调用pipe（）建立一条管道线；
两个子进程P1和P2分别向管道中写一句话：
Child1issendingamessage!
Child2issendingamessage!
而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。
要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。
三、实验步骤
1．进程的创建
任务:
编写一段程序，使用系统调用fork（）创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符；
父进程显示字符“a”，子进程分别显示字符“b”和“c”。
试观察记录屏幕上的显示结果，并分析原因。
〈程序〉
#include<
stdio.h>
main（）
{intp1,p2;
if（p1=fork（））/*子进程创建成功*/
putchar（'
b'
）;
else
{if（p2=fork（））/*子进程创建成功*/
putchar（'
c'
elseputchar（'
a'
/*父进程执行*/
}
}
<
运行结果>
bca（有时会出现bac）
分析：
从进程执行并发来看，输出bac,acb等情况都有可能。
原因：
fork（）创建进程所需的时间多于输出一个字符的时间，因此在主进程创建进程2的同时，进程1就输出了“b”，而进程2和主程序的输出次序是有随机性的，所以会出现上述结果。
2．进程的控制
任务：
修改已编写好的程序，将每个程序的输出由单个字符改为一句话，再观察程序执行时屏幕上出现的现象，并分析其原因。
如果在程序中使用系统调用lockf（）来给每个程序加锁，可以实现进程之间的互斥，观察并分析出现的现象。
〈程序1〉
{intp1,p2,i;
if（p1=fork（））
for（i=0;
i<
500;
i++）
printf（"
child%d\n"
i）;
{if（p2=fork（））
for（i=0;
i++）
printf（"
son%d\n"
else
i++）
daughter%d\n"
〈运行结果〉
child….
son…
daughter…
或child
…son
…child
…daughter
分析：
由于函数printf（）输出的字符串之间不会被中断，因此，字符串内部的字符顺序输出时不变。
但是,由于进程并发执行时的调度顺序和父子进程的抢占处理机问题，输出字符串的顺序和先后随着执行的不同而发生变化。
这与打印单字符的结果相同。
〈程序2〉
{intp1,p2,i;
{lockf（1,1,0）;
for（i=0;
printf（"
lockf（1,1,0）;
{if（p2=fork（））
{
lockf（1,1,0）;
for（i=0;
i++）printf（"
lockf（1,1,0）;
}
else
{
lockf（1,1,0）;
for（i=0;
lockf（1,0,0）;
}
}
运行结果〉
大致与未上锁的输出结果相同，也是随着执行时间不同，输出结果的顺序有所不同。
因为上述程序执行时，不同进程之间不存在共享临界资源（其中打印机的互斥性已有由操作系统保证）问题，所以，加锁与不加锁效果相同。
3．软中断通信
任务1：
编制一段程序，使用系统调用fork（）创建两个子进程，再用系统调用signal（）让父进程捕捉键盘上来的中断信号（即按ctrl+c键），当捕捉到中断信号后，父进程用系统调用kill（）向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止：
childprocess1iskilledbyparent!
childprocess2iskilledbyparent!
父进程等待两个子进程终止后，输出以下信息后终止：
parentprocessiskilled!
程序流程图>
signal.h>
unistd.h>
voidwaiting（）,stop（）;
intwait_mark;
{
intp1,p2;
if（p1=fork（））/*创建子进程p1*/
{if（p2=fork（）） /*创建子进程p2*/
{wait_mark=1;
signal（SIGINT,stop）;
/*接收到^c信号，转stop*/
waiting（）;
kill（p1,16）;
/*向p1发软中断信号16*/
kill（p2,17）;
/*向p2发软中断信号17*/
wait（0）;
/*同步*/
wait（0）;
parentprocessiskilled!
\n"
exit（0）;
{wait_mark=1;
signal（SIGINT,stop）;
waiting（）;
lockf（1,0,0）;
childprocess2iskilledbyparent!
exit（0）;
}
{wait_mark=1;
signal（SIGINT,stop）;
waiting（）;
lockf（1,0,0）;
printf（"
exit（0）;
voidwaiting（）
{while（wait_mark!
=0）;
voidstop（）
{wait_mark=0;
任务2：
在上面的任务1中，增加语句signal（SIGINT,SIG_IGN）和语句signal（SIGQUIT,SIG_IGN），观察执行结果，并分析原因。
这里，signal（SIGINT,SIG_IGN）和signal（SIGQUIT,SIG_IGN）分别为忽略键信号以及忽略中断信号。
程序>
intpid1,pid2;
intEndFlag=0;
intpf1=0;
intpf2=0;
voidIntDelete（）
{kill（pid1,16）;
kill（pid2,17）;
EndFlag=1;
voidInt1（）
{printf（"
childprocess1iskilled!
byparent\n"
voidInt2（）
childprocess2iskilled!
{intexitpid;
signal（SIGINT,SIG_IGN）;
signal（SIGQUIT,SIG_IGN）;
if（pid1=fork（））
{signal（SIGUSR1,Int1）;
pause（）;
{if（pid2=fork（））
{signal（SIGUSR1,Int1）;
signal（SIGINT,SIG_IGN）;
pause（）;
{signal（SIGINT,IntDelete）;
waitpid（-1,&
exitpid,0）;
parentprocessiskilled\n"
请读者将上述程序输入计算机后，执行并观察。
〈分析〉
由于忽略了中断与退出信号，程序会一直保持阻塞状态而无法退出。
3．进程的管道通信
编制一段程序，实现进程的管道通信。
使用系统调用pipe（）建立一条管道线。
两个子进程p1和p2分别向通道个写一句话：
child1processissendingmessage!
child2processissendingmessage!
而父进程则从管道中读出来自两个进程的信息，显示在屏幕上。
#include<
main（）
{intfd[2];
charoutpipe[100],inpipe[100];
pipe（fd）;
/*创建一个管道*/
while（（pid1=fork（））==-1）;
if（pid1==0）
{lockf（fd[1],1,0）;
sprintf（outpipe,"
child1processissendingmessage!
"
write（fd[1],outpipe,50）;
/*向管道写长为50字节的串*/
sleep（5）;
/*自我阻塞5秒*/
lockf（fd[1],0,0）;
exit（0）;
}else
{while（（pid2=fork（））==-1）;
if（pid2==0）
{lockf（fd[1],1,0）;
/*互斥*/
sprintf（outpipe,"
child2processissendingmessage!
write（fd[1],outpipe,50）;
sleep（5）;
lockf（fd[1],0,0）;
exit（0）;
}
else
{wait（0）;
read（fd[0],inpipe,50）;
/*从管道中读长为50字节的串*/
printf（"
%s\n"
inpipe）;
wait（0）;
printf（"
exit（0）;
}
}
延迟5秒后显示:
child1processissendingmessage!
再延迟5秒:
child2processissendingmessage!
四、实验体会
通过本次实验让我了解了进程的管理，通过实现进程的创建、进程的控制、进程的管道通信并编写一段程序，实现进程的软中断通信。
加深了对进程概念的理解，明确进程和程序的区别，进一步认识并发执行的实质。
巩固了课本上所学到的知识。
升级会员 