《计算机操作系统》实验指导书Word下载.docx
《《计算机操作系统》实验指导书Word下载.docx》由会员分享，可在线阅读，更多相关《《计算机操作系统》实验指导书Word下载.docx（32页珍藏版）》请在冰点文库上搜索。
{
Stringname;
intnum=0;
intsize=10;
}
classProducerimplementsRunnable
Qq;
Producer（Qq）
this.q=q;
this.q.name="
producer"
;
publicvoidrun（）
while（true）
synchronized（q）
if（q.num<
q.size）
q.num++;
System.out.println（"
producer已生产第：
"
+q.num+"
个产品!
）;
try{
Thread.currentThread（）.sleep（100）;
}catch（InterruptedExceptione）{
e.printStackTrace（）;
q.notify（）;
else
producerstop!
q.wait（）;
classConsumerimplementsRunnable
Consumer（Qq）
consumer"
if（q.num>
0）
consumer要消费第：
q.num--;
q.notifyAll（）;
consumerstop!
publicclassproject
publicstaticvoidmain（String[]args）
Qq=newQ（）;
newThread（newProducer（q））.start（）;
newThread（newConsumer（q））.start（）;
实验二进程调度实验
（1）加深对进程的概念及进程调度算法的理解；
（2）在了解和掌握进程调度算法的基础上，能编制出进程调度算法通用程序。
编程实现进程调度算法，最少实现两种算法，比较算法的优劣，并将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。
（1）了解进程调度；
（2）理解利用进程调度算法进行调度的原理；
（3）使用某种编程语言进行算法模拟。
这个仅是个例子，可以参考本例，选择其他算法进行实验）
一、例题：
设计一个有N个进程的进程调度算法。
进程调度算法：
采用最高优先数的调度算法（即把处理机分配给优先数最高的进程）。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：
进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为的指定（也可以由随机数产生）。
进程的到达时间为进程的输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤销该进程，如果运行一个时间片后，进程的已占用CPU时间还未达到所需要的运行时间，也就是进程还需要继续运行，此时应该将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要的进程都完成为止。
分析:
使用固定队列与静动态优先级结合每个优先级为0~0xFF,并且以小的数字为高优先级，大的数字为低优先级，每次皆使用循环得到最高优先级的进程并执行，然后将其动态优先级设置为最低，并将其他进程动态优先级提高，以使得每个进程都有机会运行。
进程的优先级与运行时间由随机数产生。
二、代码试例
#include<
stdlib.h>
stdio.h>
time.h>
/*常量和状态定义*/
#definePRO_NUM0x05
#defineMAX_TIME0xFF
/*状态宏*/
#defineWAIT0x01
#defineRUN0x02
#defineFINISH0x03
#defineID_ERROR0x10
#defineMIN_PRIOR0xFF
#defineMAX_PRIOR0x00
typedefunsignedintUint32;
/*进程PCB*/
structPCB_Info
Uint32s_id;
Uint32s_static_prior;
Uint32s_dynamic_prior;
Uint32s_start_time;
Uint32s_need_time;
Uint32s_used_time;
Uint32s_state;
};
/*进程队列*/
PCB_Infog_queue[5];
Uint32g_time;
/*模拟进程执行函数*/
voidSimulator（）;
/*初始化5个进程函数*/
voidInit_Process（）;
/*初始化进程队列函数*/
voidInit_Queue（）;
/*创建进程函数*/
Uint32Create_Process（Uint32pri,Uint32needtime）;
/*系统运行函数*/
voidRun_Process（）;
/*得到最高优先级进程ID函数*/
Uint32Get_PriProcess（）;
/*进程时间片执行函数*/
voidWork_Process（Uint32id）;
/*改变进程状态和优先级函数*/
voidChange_Process（Uint32id）;
/*打印进程状态函数*/
voidPrint_State（）;
/*结束系统函数*/
voidEnd_Process（）;
/*入口函数*/
intmain（intargc,char*argv[]）
Simulator（）;
return0;
voidSimulator（）
Init_Process（）;
Run_Process（）;
End_Process（）;
voidInit_Process（）
inti;
Uint32id;
srand（（unsigned）time（NULL））;
Init_Queue（）;
for（i=0;
i<
PRO_NUM;
++i）
{
/*在这里修改随机数的范围，建议优先级取值为0到4之间，进程工作总时间为1到10之间*/
id=Create_Process（rand（）%4,1+rand（）%10）;
if（id!
=ID_ERROR）
printf（"
**********************************\n"
创建进程成功\n"
进程ID号为:
%d\n"
id）;
进程的静态优先权为:
g_queue[id].s_static_prior）;
进程的动态优先权为:
g_queue[id].s_dynamic_prior）;
进程的到达时间为:
g_queue[id].s_start_time）;
进程需要时间为:
g_queue[id].s_need_time）;
进程已用CPU时间为:
g_queue[id].s_used_time）;
进程的状态为:
g_queue[id].s_state）;
\n"
}
else
创建进程失败\n"
voidInit_Queue（）
g_queue[i].s_id=i;
g_queue[i].s_dynamic_prior=MIN_PRIOR;
g_queue[i].s_need_time=0;
g_queue[i].s_start_time=0;
g_queue[i].s_static_prior=MIN_PRIOR;
g_queue[i].s_used_time=0;
g_queue[i].s_state=FINISH;
Uint32Create_Process（Uint32pri,Uint32needtime）
inti=0;
Uint32id=ID_ERROR;
if（g_queue[i].s_state==FINISH）
id=g_queue[i].s_id;
g_queue[i].s_need_time=needtime;
g_queue[i].s_start_time=g_time;
g_queue[i].s_state=WAIT;
g_queue[i].s_static_prior=pri;
g_queue[i].s_used_time=0x0;
break;
returnid;
voidRun_Process（）
while（（id=Get_PriProcess（））!
Work_Process（id）;
Change_Process（id）;
voidPrint_State（）
时间进程ID\t状态已用时间需要时间开始时间静优先级动优先级\n"
{
%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n"
g_time,g_queue[i].s_id,g_queue[i].s_state,g_queue[i].s_used_time,g_queue[i].s_need_time,
g_queue[i].s_start_time,g_queue[i].s_static_prior,g_queue[i].s_dynamic_prior）;
Uint32Get_PriProcess（）
inti,prev_id=ID_ERROR;
Uint32prior=MIN_PRIOR*2,temp_prior;
if（g_queue[i].s_state!
=FINISH）
temp_prior=g_queue[i].s_dynamic_prior+g_queue[i].s_static_prior;
if（temp_prior<
=prior）
id=i;
prior=temp_prior;
voidWork_Process（Uint32id）
++g_time;
g_queue[id].s_state=RUN;
++g_queue[id].s_used_time;
Print_State（）;
voidChange_Process（Uint32id）
if（g_queue[id].s_need_time==g_queue[id].s_used_time）
g_queue[id].s_state=FINISH;
g_queue[id].s_dynamic_prior=MIN_PRIOR;
g_queue[id].s_state=WAIT;
if（（i!
=id）&
&
（g_queue[i].s_state!
=FINISH））
g_queue[i].s_dynamic_prior>
0?
--g_queue[i].s_dynamic_prior:
g_queue[i].s_dynamic_prior=0;
voidEnd_Process（）
所有进程结束状态:
所有进程已经结束!
实验三银行家算法模拟
（1）理解利用银行家算法避免死锁的问题；
（2）在了解和掌握银行家算法的基础上，编制银行家算法通用程序。
（3）理解和掌握安全序列、安全性算法
编程实现银行家算法，能从屏幕完成资源的手动申请，算法执行结果的及时反馈等，并将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。
（1）了解和理解死锁；
（2）理解利用银行家算法避免死锁的原理；
（3）使用某种编程语言模拟该算法。
一、安全状态
指系统能按照某种顺序如<
P1,P2,…,Pn>
（称为<
序列为安全序列），为每个进程分配所需的资源，直至最大需求，使得每个进程都能顺利完成。
二、银行家算法
假设在进程并发执行时，进程i提出请求j类资源k个后，表示为Requesti[j]=k。
系统按下述步骤进行安全检查：
（1）如果Requesti≤Needi则继续以下检查，否则显示需求申请超出最大需求值的错误。
（2）如果Requesti≤Available则继续以下检查，否则显示系统无足够资源，Pi阻塞等待。
（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：
Available［j］∶=Available［j］-Requesti［j］;
Allocation［i,j］∶=Allocation［i,j］+Requesti［j］;
Need［i,j］∶=Need［i,j］-Requesti［j］;
（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
若安全，才正式将资源分配给进程Pi，以完成本次分配；
否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
三、安全性算法
（1）设置两个向量：
①工作向量Work:
它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work∶=Available;
②Finish:
它表示系统是否有足够的资源分配给进程，使之运行完成。
开始时先做Finish［i］∶=false;
当有足够资源分配给进程时，再令Finish［i］∶=true。
（2）从进程集合中找到一个能满足下述条件的进程：
①Finish［i］=false;
②Need［i,j］≤Work［j］；
若找到，执行步骤（3），否则，执行步骤（4）。
（3）当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Ø
Work［j］∶=Work［i］+Allocation［i,j］;
Finish［i］∶=true;
gotostep2;
（4）如果所有进程的Finish［i］=true都满足，则表示系统处于安全状态；
否则，系统处于不安全状态。
参考实验步骤如下：
（1）参考下图流程编写安全性算法。
（2）编写统一的输出格式。
每次提出申请之后输出申请成功与否的结果。
如果成功还需要输出变化前后的各种数据，并且输出安全序列。
（3）参考下图所示流程图编写银行家算法。
（4）编写主函数来循环调用银行家算法。
示例：
intmain（）
intclaim[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
//各线程最大需求量
intallocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
//各线程已分配资源
inti,j,k,l=0,count=0,m=0;
intC_A[5][3]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};
//各进程仍需要的各类资源
intresult[5]={-1,-1,-1,-1,-1};
//存放预分配成功的线程
intcurrentavail[3]={3,3,2};
//当前可分配资源
银行家总共拥有的各类资源的总数：
\nABC\n1057\n"
银行目前仍剩下的各类资源的数量：
\nABC\n332\n"
各进程对各类资源的最大需求量：
\nABC\n"
5;
i++）
printf（"
P%d:
"
i）;
for（j=0;
j<
3;
j++）
{
printf（"
%d"
claim[i][j]）;
C_A[i][j]=claim[i][j]-allocation[i][j];
}
各进程已分配到的各类资源：
allocation[i][j]）;
各进程仍需的各类资源数量：
C_A[i][j]）;
while（result[l]==-1）//
for（k=0;
k<
k++）
if（result[k]==-1）
{
for（j=0;
//判断各线程对各资源仍需量是否小于当前可分配资源总量,此量为正数才正常
if（C_A[k][j]<
=currentavail[j]&
C_A[k][j]>
=0）
{
//把满足条件的进程的已分配资源加到当前可分配资源中
currentavail[j]=currentavail[j]+allocation[k][j];
m++;
if（m==3）
{
result[l]=k;
//只有ABC三类资源都满足才把相应的线程记入数组result中
m=0;
}
}
elsebreak;
//否则退出循环,打印"
系统不安全"
l++;
}
for（i=0;
l;
if（result[i]!
=-1）
print
升级会员 