江苏科技大学操作系统实验.docx
《江苏科技大学操作系统实验.docx》由会员分享，可在线阅读，更多相关《江苏科技大学操作系统实验.docx（64页珍藏版）》请在冰豆网上搜索。
江苏科技大学操作系统实验
操作系统实验
实验一进程调度
一、实验目的
多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。
二、实验要求
1．设计进程调度算法，进程数不定
2．包含几种调度算法，并加以实现
3．输出进程的调度过程——进程的状态、链表等。
三、参考例
1．题目——优先权法、轮转法
简化假设
1）进程为计算型的（无I/O）
2）进程状态：
ready、running、finish
3）进程需要的CPU时间以时间片为单位确定
2．算法描述
1）优先权法——动态优先权
当前运行进程用完时间片后，其优先权减去一个常数。
2）轮转法
四、
实验流程图
注意：
1．产生的各种随机数的取值范围加以限制，如所需的CPU时间限制在1~20之间。
2．进程数n不要太大通常取4~8个
3．使用动态数据结构
4．独立编程
5．至少三种调度算法
6．若有可能请在图形方式下，将PCB的调度用图形成动画显示。
五．实验过程：
（1）输入：
进程流文件（1.txt），其中存储的是一系列要执行的进程，每个作业包括四个数据项：
进程名进程状态（1就绪2等待3运行）所需时间优先数（0级最高）
进程01502
进程12104
进程21150
进程33285
进程42191
进程5387
输出:
进程执行流等待时间，平均等待时间
本程序包括:
FIFO算法，优先数调度算法，时间片轮转调度算法
（2）程序代码
package进程调度;
importjava.util.*;
classPCB//创建进程块
{
intId;//进程编号
intUseTime;//服务时间
intNeedTime;//需要时间
intPerior;//优先级
StringStatus;//状态
PCB（）
{
Id++;
UseTime=0;
NeedTime=（int）Math.round（Math.random（）*6）+1;//随机产生需要时间
Perior=（int）Math.round（Math.random（）*5）+1;//随即产生优先级
Status="Ready";//初始状态为就绪
}
}
classFound//定义系统处理方法类
{
ArrayListsequnce;//创建就绪队列
PCBpcb[]=newPCB[5];
intStartTime=0;
intSystemTime=（int）（Math.random（）*3）+1;//随即产生系统时间
Found（）
{
sequnce=newArrayList（）;
for（inti=0;i<5;i++）
{
pcb[i]=newPCB（）;
pcb[i].Id=i+1;
sequnce.add（pcb[i]）;
}
}
voidFCFS（）//先来先服务算法
{
PCBRunning=null;
while（sequnce.size（）>0）//就绪队列不为空
{
Running=sequnce.remove（0）;
Running.UseTime=Running.NeedTime;
Running.NeedTime=0;
Running.Perior=0;
System.out.println（"当前系统时间：
"+SystemTime）;
SystemTime+=Running.UseTime;
ShowMessages（Running）;
}
}
voidRR（）//时间片轮换算法
{
PCBRunning=null;
intTime=SystemTime;
while（sequnce.size（）>0）
{
System.out.println（"当前系统时间：
"+SystemTime）;
Running=sequnce.remove（0）;
if（Running.NeedTime<=Time）
{
Running.UseTime=Running.NeedTime;
Running.NeedTime=0;
Running.Perior=0;
Running.Status="Finish";
SystemTime+=Running.UseTime;
}
else
{
Running.UseTime+=Time;
Running.NeedTime-=Time;
Running.Perior--;
Running.Status="Ready";
sequnce.add（Running）;
SystemTime+=Time;
}
ShowMessages（Running）;
}
}
voidShowMessages（PCBp）//输出信息
{
System.out.println（"当前运行进程：
"+p.Id+""+"服务时间：
"+p.UseTime+""+"需要时间：
"+p.NeedTime+""+"优先级：
"+p.Perior+""+"状态：
"+p.Status）;
if（sequnce.size（）>0）
{
System.out.println（"当前就绪进程：
"）;
for（PCBp1:
sequnce）
{
System.out.println（"进程编号：
"+p1.Id+""+"服务时间：
"+p1.UseTime+""+"需要时间：
"+p1.NeedTime+""+"优先级：
"+p1.Perior+""+"状态：
"+p1.Status）;
System.out.println（"--------------------------------------------------------------------------"）;
}
}
else
{
System.out.println（"当前系统中已经没有就绪进程！
"）;}
System.out.println（'\n'）;
}
}
classMenu//主界面菜单
{
Scannersc=newScanner（System.in）;intprint（）{System.out.println（"********************************************"）;
System.out.println（"进调度算法演示"）;
System.out.println（"********************************************"）;
System.out.println（"1.先来先服务（FCFS）算法"）;
System.out.println（"2.时间片轮换（RR）算法"）;
System.out.println（"3.退出该程序"）;
System.out.print（"请选择所要采用的算法：
"）;
intflag=sc.nextInt（）;
returnflag;
}
voidselect（）
{
intflag=print（）;switch（flag）
{
case1:
FoundProcess1=newFound（）;
Process1.FCFS（）;print（）;
case2:
FoundProcess2=newFound（）;
Process2.RR（）;print（）;
case3:
System.exit（0）;
default:
break;
}
}
}
package进程调度;
publicclassProcessControl{publicstaticvoidmain（Stringargs[]）
{
MenuTencent=newMenu（）;
Tencent.select（）;
}
}
（3）运行结果：
实验二银行家算法
一、实验目的
死锁会引起计算机工作僵死，因此操作系统中必须防止。
本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。
二、实验要求
设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。
系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析；
三、数据结构
1．可利用资源向量Available，它是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源的数目，其初始值是系统中所配置的该类全部可用资源数目。
其数值随该类资源的分配和回收而动态地改变。
如果Available（j）=k，标是系统中现有Rj类资源k个。
2．最大需求矩阵Max，这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max（i，j）=k，表示进程i需要Rj类资源的最大数目为k。
3．分配矩阵Allocation，这是一个n×m的矩阵，它定义了系统中的每类资源当前一分配到每一个进程的资源数。
如果Allocation（i，j）=k，表示进程i当前已经分到Rj类资源的数目为k。
Allocationi表示进程i的分配向量，有矩阵Allocation的第i行构成。
4．需求矩阵Need，这是一个n×m的矩阵，用以表示每个进程还需要的各类资源的数目。
如果Need（i，j）=k，表示进程i还需要Rj类资源k个，才能完成其任务。
Needi表示进程i的需求向量，由矩阵Need的第i行构成。
上述三个矩阵间存在关系：
Need（i，j）=Max（i，j）-Allocation（i，j）；
四、银行家算法
Requesti是进程Pi的请求向量。
Requesti（j）=k表示进程Pi请求分配Rj类资源k个。
当Pi发出资源请求后，系统按下述步骤进行检查：
1．如果Requesti≤Need，则转向步骤2；否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。
2．如果Requesti≤Available，则转向步骤3；否则，表示系统中尚无足够的资源满足Pi的申请，Pi必须等待。
3．系统试探性地把资源分配给进程Pi，并修改下面数据结构中的数值：
Available=Available-Requesti
Allocationi=Allocationi+Requesti
Needi=Needi-Requesti
4．系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
如果安全才正式将资源分配给进程Pi，以完成本次分配；否则，将试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
假定系统有5个进程（p0,p1,p2,p3,p4）和三类资源（A，B，C），各种资源的数量分别为10，5，7，在T0时刻的资源分配情况如下图：
MaxAllocationNeedAvailable
ABCABCABCABC
P0753010743332
（230）
P1322200122
（302）（020）
P2902302600
P3222211011
P4433002431
五、安全性算法
1．设置两个向量。
Work：
它表示系统可提供给进程继续运行的各类资源数目，它包含m个元素，开始执行安全性算法时，Work=Available。
Finish：
它表示系统是否有足够的资源分配给进程，使之运行完成，开始Finish（I）=false；当有足够资源分配给进程Pi时，令Finish（i）=true；
2．从进程集合中找到一个能满足下述条件的进程。
Finish（i）==false；
Needi≤work；
如找到则执行步骤3；否则，执行步骤4；
3．当进程Pi获得资源后，可顺利执行直到完成，并释放出分配给它的资源，故应执行
Work=work+Allocationi
Finish（i）=true；转向步骤2；
4．若所有进程的Finish（i）都为true，则表示系统处于安全状态；否则，系统处于不安全状态。
六、系统流程图
七．银行家算法程序代码
packageyinhangjia;
importjava.util.Scanner;
publicclassbanker{
privateintProcess=0;//定义最大进程数目
privateintResource=0;//定义最大资源类数
privateintWork[];//定义系统可提供给进程继续运行所需的各类资源数目
privateintMAX[][];//定义进程最大资源需求
privateintAllocation[][];//定义进程当前已用资源数目
privateintneed[][];//定义进程需要资源数目
privateintRequest[][];//定义进程请求资源向量
privatebooleanfinish[];//定义进程完成标志
privateintAvailable[];
privateintP[];
privateScannerin=newScanner（System.in）;//定义全局输入流
publicvoidclose（）{
in.close（）;
}//构造函数，初始化各向量
publicbanker（）throwsException{
inti,j;
System.out.print（"请输入当前进程的个数:
"）;
Process=in.nextInt（）;
System.out.print（"请输入系统资源种类的类数:
"）;
Resource=in.nextInt（）;
//初始化各个数组
Available=newint[Resource];
Work=newint[Resource];
MAX=newint[Process][Resource];
Allocation=newint[Process][Resource];
need=newint[Process][Resource];
Request=newint[Process][Resource];
finish=newboolean[Process];
P=newint[Process];
System.out.println（"请输入每个进程最大资源需求量,按"+Process+"*"+Resource
+"矩阵输入：
"）;
for（i=0;iSystem.out.print（"请输入P"+（i+1）+"进程各类资源最大需求量:
"）;
for（j=0;jMAX[i][j]=in.nextInt（）;
}
System.out.println（"请输入每个进程已分配的各资源数,也按照"+Process+"*"+Resource
+"矩阵输入：
"）;
for（i=0;iSystem.out.print（"请输入P"+（i+1）+"进程各类资源已分配的资源数:
"）;
for（j=0;jAllocation[i][j]=in.nextInt（）;
need[i][j]=MAX[i][j]-Allocation[i][j];
if（need[i][j]<0）{
System.out.println（"您输入的第"+（i+1）+"个进程所拥有的第"
+（j+1）+"个资源数错误,请重新输入:
"）;
j--;
continue;
}
}
}
System.out.print（"请输入系统各类资源可用的数目:
"）;
for（i=0;iAvailable[i]=in.nextInt（）;
}
}
publicvoidBank（）throwsException{
intj,i;
inttempAvailable[]=newint[Resource];
inttempAllocation[]=newint[Resource];
inttempNeed[]=newint[Resource];
System.out.println（"----------------------------------------------------------"）;
System.out.print（"请输入要申请资源的进程号（当前共有"+Process+"个进程,如为进程P1申请，请输入1，以此类推）"）;
i=in.nextInt（）-1;
System.out.print（"请输入P"+（i+1）+"进程申请的各资源的数量"）;
for（j=0;jRequest[i][j]=in.nextInt（）;
}
for（j=0;jif（Request[i][j]>need[i][j]）{
System.out.println（"您输入的申请的资源数超过进程的需求量!
请重新输入!
"）;
continue;
}
if（Request[i][j]>Available[j]）{
System.out.println（"您输入的申请数超过系统可用的资源数!
请重新输入!
"）;
continue;
}
}
for（j=0;jtempAvailable[j]=Available[j];
tempAllocation[j]=Allocation[i][j];
tempNeed[j]=need[i][j];
Available[j]=Available[j]-Request[i][j];
Allocation[i][j]=Allocation[i][j]+Request[i][j];
need[i][j]=need[i][j]-Request[i][j];
}
if（Safe（））{
System.out.println（"分配给P"+i+"进程成功!
"）;
System.out.print（"分配前系统可用资源：
"）;
for（intk=0;kSystem.out.print（tempAvailable[k]+""）;
System.out.print（"\n分配前进程P"+i+"各类资源已分配数量:
"）;
for（intk=0;kSystem.out.print（tempAllocation[k]+""）;
System.out.print（"\n分配前进程P"+i+"各类资源需求数量:
"）;
for（intk=0;kSystem.out.print（tempNeed[k]+""）;
System.out.print（"\n分配后系统可用资源：
"）;
for（intk=0;kSystem.out.print（Available[k]+""）;
System.out.print（"\n分配后进程P"+i+"各类资源已分配数量:
"）;
for（intk=0;kSystem.out.print（Allocation[i][k]+""）;
System.out.print（"\n分配后进程P"+i+"各类资源需求数量:
"）;
for（intk=0;kSystem.out.print（need[i][k]+""）;
System.out.println（）;
}else{
System.out.println（"申请资源失败!
"）;
for（j=0;jAvailable[j]=Available[j]+Request[i][j];
Allocation[i][j]=Allocation[i][j]+Request[i][j];
need[i][j]=need[i][j]+Request[i][j];
}
}
for（i=0;ifinish[i]=false;
}
}//安全性算法
publicbooleanSafe（）{
inti,j,k,t=0;
Work=newint[Resource];
for（i=0;iWork[i]=Available[i];
for（i=0;ifinish[i]=false;
}
升级会员 