操作系统实验报告Word文件下载.docx
《操作系统实验报告Word文件下载.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告Word文件下载.docx（21页珍藏版）》请在冰豆网上搜索。
if（p1==0）
for（i＝0;
i<
500；
i++）
printf（"
child％d\n”，i）;
while（（p2=fork（））==-1）;
if（p2==0）
for（i=0;
500;
i++）
printf（“son％d\n”,i）
for（i＝0，i<
500;
printf（"
daughter％d\n”，i）;
程序2>
main（）
intp1，p2，i；
while（（pl=fork（））==-1）;
if（pl==0）
lockf（1，1，0），
for（i=0;
i++）printf（（“child%d/n”,i）;
lockf（1，0，0）;
while（（p2=fork（））==-1）;
lockf（1，1，0）;
for（i=0;
i++）printf（“son%d\n”,i）;
i++）printf（“daughter%d\n”,i）;
}
实验三实现进程的软中断通信
任务1程序>
signal.h>
unistd．h>
voidwaiting（），stop（）;
intwait_mark;
intpl，p2,stdout;
while（（p1=fork（））==-1）;
/*创建进程p1*/
if（p1>
0）
while（（p2=fork（））==-1）;
if（p2>
wait_mark=1;
signal（SIGINT，stop）;
/*接收Del信号，并转stop*/
waiting（0）;
kill（p1，16）;
/*向p1发中断信号16*/
kill（p2，17）;
/*向p2发中断信号17*/
wait（0）;
/*同步*/
printf（“parentprocessiskilled!
\n”）
exit（0）;
signal（SIGINT,SIG_IGN）;
********
signal（17，stop）;
printf（“%d”,SIG_DFL）;
waiting（）;
lockf（stdout，1，0）；
printf（“childprocess2iskilledbyparent!
\n”）;
lockf（stdout，0，0）;
exit（0）;
}
wait_mark=l;
signal（16，stop）;
printf（%d”,SIG_DEL）;
waiting（）；
lockf（stdout，1，0）;
childprocess1iskilledbyparent!
\n”）;
1ockf（stdout，0，0）;
voidwaiting（）
while（wait_mark!
=0）;
voidstop（）
wait_mark=0;
任务2程序>
#include<
#includc<
signal．h>
intpid1，pid2；
intEndFlag=0;
pf1=0；
pf2=0；
voidIntDelete（）
kill（pidl，16）;
kill（pid2，17）;
EndFlag=1;
voidIntl（）
printf（“childprocessliskilled!
byparent\n”）;
exit（0）；
voidInt2（）
printf（“childprocess2iskilled!
byparent＼n”）;
exit（0）;
intexitpid;
signal（SIGINT，SIG_IGN）;
signal（SIGQUIT，SIG_IGN）；
while（（pid1＝fork（））＝-1）;
if（pid＝0）
signal（SIGUSRl，Intl）；
pause（）；
exit（0）；
while（（pid=fork（））=-1）;
if（pid2=0）
signal（SIGUSRl，Intl）；
signal（SIGINT，SIG_IGN）;
pause（）;
signal（SIGINT，IntDelete）;
waitpid（-1，&
exitcode，0）;
printf（“parentprocessiskilled\n”）;
实验四进程的管道通信
intpidl，pid2；
intfd[2];
charOutPipe[l00]，InPipe[l00];
pipe（fd）;
while（（pidl=fork（））==-1）;
if（pidl==0）
lockf（fd[1]，1，0）;
sprintf（OutPipe，“child1processissendingmessage!
”）;
write（fd[1]，OutPipe，50）;
sleep（5）;
lockf（fd[1]，0,0）；
while（（pid2=fork（））==-1）;
if（pid2==0）
1ockf（fd[1]，1，0）；
sprintf（OutPipe，“child2processissendingmessage!
“）；
write（fd[1]，OutPipe，50）；
sleep（5）；
lockf（fd[l]，0，0）；
read（fd[0]，InPipe，50）;
printf（“％s\n”，InPipe）；
wait（0）；
read（fd[0]，InPipe，50）；
printf（“%s\n”,InPipe）;
实验五使用动态优先权的进程调度算法模拟
源程序：
#include<
#defineN5
voidinit（）;
voidprint（）;
intgetRunning（）;
voidsort（）;
intrun（inttime）;
enumSTATE{Ready,Run,Block,RunOut};
structPROCESS
intID;
intPriority;
intCputime;
intAlltime;
intStartblock;
intBlocktime;
enumSTATEState;
}Process[N];
intREADY[N];
intBLOCK[N];
intRUNOUT[N][2];
intmain（）
intTime=0;
init（）;
printf（"
Time:
%d\n"
Time）;
sort（）;
print（）;
while
（1）
Time++;
getchar（）;
if（run（Time））
break;
//所有进程执行完毕，跳出循环
return0;
voidinit（）
inti;
for（i=0;
i<
N;
++i）
READY[i]=-1;
BLOCK[i]=-1;
RUNOUT[i][0]=-1;
RUNOUT[i][1]=-1;
Process[i].ID=i;
Process[i].Cputime=0;
Process[i].State=Ready;
Process[i].Startblock=-1;
Process[i].Blocktime=0;
Process[0].Priority=9;
Process[0].Alltime=3;
Process[0].Startblock=2;
Process[0].Blocktime=3;
Process[1].Priority=38;
Process[1].Alltime=3;
Process[2].Priority=30;
Process[2].Alltime=6;
Process[3].Priority=29;
Process[3].Alltime=3;
Process[4].Priority=0;
Process[4].Alltime=4;
voidprint（）
if（getRunning（）>
=0）
\tRUNNINGPROG:
%d\n"
getRunning（））;
//打印正在运行的进程
\tREADY_QUEUE:
"
）;
if（READY[i]>
if（Process[READY[i]].State==Ready）
->
%d"
Process[READY[i]].ID）;
//打印就绪进程
}
\n\tBLOCK_QUEUE:
if（BLOCK[i]>
Process[BLOCK[i]].ID）;
//打印阻塞进程
\n=====================================================\n"
ID\t"
\t%d"
Process[i].ID）;
\nPRIORITY"
Process[i].Priority）;
\nCPUTIME\t"
Process[i].Cputime）;
\nALLTIME\t"
Process[i].Alltime）;
\nSTARTBLOCK"
Process[i].Startblock）;
\nBLOCKTIME"
Process[i].Blocktime）;
\nSTATE\t"
switch（Process[i].State）
case0:
\tReady"
case1:
\tRun"
if（Process[i].Alltime==0）
Process[i].State=RunOut;
elseProcess[i].State=Ready;
case2:
\tBlock"
case3:
\tRunOut"
\n"
\tRUNOUTLIST:
if（RUNOUT[i][0]>
%d（%d）"
Process[RUNOUT[i][0]].ID,RUNOUT[i][1]）;
intgetRunning（）
if（Process[i].State==Run）
returni;
if（Process[i].Startblock==0）
if（Process[i].Blocktime>
Process[READY[0]].State=Run;
returnREADY[0];
return-1;
voidsort（）
inti,j,k;
{/*对就绪进程进行排序*/
if（Process[i].State==Ready||Process[i].State==Run）
{
if（Process[i].Alltime==0）//跳过已执行完的进程
continue;
for（j=0;
j<
++j）
if（READY[j]<
0）//将i插入就绪队列
READY[j]=i;
break;
elseif（Process[i].Priority<
=Process[READY[j]].Priority）
}/*若i的优先级大于j则将j及j后面的进程后移一位，将i插入j的位置*/
else
for（k=N-1;
k>
j;
--k）
READY[k]=READY[k-1];
READY[j]=i;
/*对阻塞进程进行排序*/
elseif（Process[i].State==Block）
for（j=0;
if（BLOCK[j]<
BLOCK[j]=i;
elseif（Process[i].Blocktime>
=Process[BLOCK[j]].Blocktime）
continue;
BLOCK[k]=BLOCK[k-1];
intrun（inttime）
inti,runNum;
runNum=READY[0];
if（runNum<
0&
&
BLOCK[0]<
EveryprocessisOVER!
return1;
if（runNum>
Process[runNum].Priority-=3;
Process[runNum].Alltime-=1;
Process[runNum].Cputime+=1;
Process[runNum].State=Run;
if（i!
=runNum）
if（Process[i].State==Ready）
Process[i].Priority+=1;
Process[i].Blocktime-=1;
if（Process[i].Blocktime==0）
if（Process[runNum].Alltime==0）
if（RUNOUT[i][0]<
RUNOUT[i][0]=runNum;
RUNOUT[i][1]=time;
elseif（Process[runNum].Startblock>
Process[runNum].Startblock-=1;
if（Process[runNum].Startblock==0）
Process[runNum].State=Block;
elseif（BLOCK[0]>
++i）{
if（Process[i].State==Block）{
if（Process[i].Blocktime==0）{
升级会员 