江苏科技大学操作系统实验

操作系统实验实验一进程调度实验目的多道程序设计中，经常是假设干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。实验要求设计进程调度算法，进程数不定包含几种调度算法，并加以实现输出进程的调度过程——进程的状态、链表等。参考例题目——优先权法、轮转法简化假设进程为计算型的〔无I/O〕进程状态：ready、running、finish进程需要的CPU时间以时间片为单位确定算法描述优先权法——动态优先权当前运行进程用完时间片后，其优先权减去一个常数。轮转法开始键盘输入进程数n，和调度方法的选择开始键盘输入进程数n，和调度方法的选择优先权法？轮转法产生n个进程，对每个进程产生一个PCB，并用随机数产生进程的优先权及进程所需的CPU时间按优先权大小，把n个进程拉成一个就绪队列初始化其他数据结构区链首进程投入运行时间片到，进程所需的CPU时间减1，优先权减3，输出个进程的运行情况所需的CPU时间=0？撤销进程就绪队列为空？结束将进程插入就绪队列NYNYYBN产生n个进程，对每个进程用随机数产生进程的轮转时间片数及进程所需的时间片数，已占用CPU产生n个进程，对每个进程用随机数产生进程的轮转时间片数及进程所需的时间片数，已占用CPU的时间片数置为0按进程产生的先后次序拉成就绪队列链链首进程投入运行时间片到，进程所需时间片数减1，已占用CPU时间片数加1输出各进程的运行情况进程所需时间片数=0？撤销该进程就绪队列为空吗？占用CPU的时间片数=轮转时间片数？占用CPU的时间片数置为0把该进程插入就绪队列尾BNYNYY结束N产生的各种随机数的取值范围加以限制，如所需的CPU时间限制在1~20之间。进程数n不要太大通常取4~8个使用动态数据结构独立编程至少三种调度算法假设有可能请在图形方式下，将PCB的调度用图形成动画显示。五．实验过程：〔1〕输入：进程流文件〔1.txt〕，其中存储的是一系列要执行的进程，每个作业包括四个数据项：进程名进程状态(1就绪2等待3运行)所需时间优先数(0级最高)进程01502进程12104进程21150进程33285进程42191进程5387输出:进程执行流等待时间，平均等待时间本程序包括:FIFO算法，优先数调度算法，时间片轮转调度算法程序代码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//定义系统处理方法类{ArrayList<PCB>sequnce;//创立就绪队列PCBpcb[]=newPCB[5];intStartTime=0;intSystemTime=(int)(Math.random()*3)+1;//随即产生系统时间Found(){sequnce=newArrayList<PCB>();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();}}运行结果：实验二银行家算法实验目的死锁会引起计算机工作僵死，因此操作系统中必须防止。本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。实验要求设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析；数据结构可利用资源向量Available，它是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源的数目，其初始值是系统中所配置的该类全部可用资源数目。其数值随该类资源的分配和回收而动态地改变。如果Available〔j〕=k，标是系统中现有Rj类资源k个。最大需求矩阵Max，这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max〔i，j〕=k，表示进程i需要Rj类资源的最大数目为k。分配矩阵Allocation，这是一个n×m的矩阵，它定义了系统中的每类资源当前一分配到每一个进程的资源数。如果Allocation〔i，j〕=k，表示进程i当前已经分到Rj类资源的数目为k。Allocationi表示进程i的分配向量，有矩阵Allocation的第i行构成。需求矩阵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发出资源请求后，系统按下述步骤进行检查：如果Requesti≤Need，那么转向步骤2；否那么，认为出错，因为它所请求的资源数已超过它当前的最大需求量。如果Requesti≤Available，那么转向步骤3；否那么，表示系统中尚无足够的资源满足Pi的申请，Pi必须等待。系统试探性地把资源分配给进程Pi，并修改下面数据结构中的数值：Available=Available-RequestiAllocationi=Allocationi+RequestiNeedi=Needi-Requesti系统执行平安性算法，检查此次资源分配后，系统是否处于平安状态。如果平安才正式将资源分配给进程Pi，以完本钱次分配；否那么，将试探分配作废，恢复原来的资源分配状态，让进程Pi等待。假定系统有5个进程〔p0,p1,p2,p3,p4〕和三类资源〔A，B，C〕，各种资源的数量分别为10，5，7，在T0时刻的资源分配情况如以下图：MaxAllocationNeedAvailableABCABCABCABCP0753010743332(230)P1322200122(302)(020)P2902302600P3222211011P4433002431平安性算法设置两个向量。Work：它表示系统可提供应进程继续运行的各类资源数目，它包含m个元素，开始执行平安性算法时，Work=Available。Finish：它表示系统是否有足够的资源分配给进程，使之运行完成，开始Finish〔I〕=false；当有足够资源分配给进程Pi时，令Finish〔i〕=true；从进程集合中找到一个能满足下述条件的进程。Finish〔i〕==false；Needi≤work；如找到那么执行步骤3；否那么，执行步骤4；当进程Pi获得资源后，可顺利执行直到完成，并释放出分配给它的资源，故应执行Work=work+AllocationiFinish〔i〕=true；转向步骤2；假设所有进程的Finish〔i〕都为true，那么表示系统处于平安状态；否那么，系统处于不平安状态。六、系统流程图开始开始输入资源数m,及各类资源总数，初始化Available向量输入进程数n，i=1输入进程i的最大需求向量max。i≤nmax≤资源总数提示错误重新输入i加1任选一个进程作为当前进程输入该进程的资源请求量Request调用银行家算法，及平安性算法，完成分配，或并给出提示该进程的Need向量为0该进程已运行结束Need矩阵为0所有进程运行都结束结束NYYNNY初始化need矩阵NY银行家算法程序代码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;i<Process;i++){ System.out.print("请输入P"+(i+1)+"进程各类资源最大需求量:");for(j=0;j<Resource;j++)MAX[i][j]=in.nextInt(); } System.out.println("请输入每个进程已分配的各资源数,也按照"+Process+"*"+Resource +"矩阵输入：");for(i=0;i<Process;i++){ System.out.print("请输入P"+(i+1)+"进程各类资源已分配的资源数:");for(j=0;j<Resource;j++){Allocation[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;i<Resource;i++){Available[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;j<Resource;j++){Request[i][j]=in.nextInt(); }for(j=0;j<Resource;j++){if(Request[i][j]>need[i][j]){ System.out.println("您输入的申请的资源数超过进程的需求量!请重新输入!");continue; }if(Request[i][j]>Available[j]){ System.out.println("您输入的申请数超过系统可用的资源数!请重新输入!");continue; } }for(j=0;j<Resource;j++){ tempAvailable[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;k<Resource;k++) System.out.print(tempAvailable[k]+""); System.out.print("\n分配前进程P"+i+"各类资源已分配数量:");for(intk=0;k<Resource;k++) System.out.print(tempAllocation[k]+""); System.out.print("\n分配前进程P"+i+"各类资源需求数量:");for(intk=0;k<Resource;k++) System.out.print(tempNeed[k]+""); System.out.print("\n分配后系统可用资源：");for(intk=0;k<Resource;k++) System.out.print(Available[k]+""); System.out.print("\n分配后进程P"+i+"各类资源已分配数量:");for(intk=0;k<Resource;k++) System.out.print(Allocation[i][k]+""); System.out.print("\n分配后进程P"+i+"各类资源需求数量:");for(intk=0;k<Resource;k++) System.out.print(need[i][k]+""); System.out.println(); }else{ System.out.println("申请资源失败!");for(j=0;j<Resource;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]; } }for(i=0;i<Process;i++){finish[i]=false; } }//平安性算法publicbooleanSafe(){inti,j,k,t=0;Work=newint[Resource];for(i=0;i<Resource;i++)Work[i]=Available[i];for(i=0;i<Process;i++){finish[i]=false; }for(i=0;i<Process;i++){if(finish[i]==true){continue; }else{for(j=0;j<Resource;j++){if(need[i][j]>Work[j]){break; } }if(j==Resource){finish[i]=true;for(k=0;k<Resource;k++){Work[k]+=Allocation[i][k]; }P[t++]=i; i=-1; }else{continue; } }if(t==Process){ System.out.print("当前系统是平安的,存在一平安序列:");for(i=0;i<t;i++){ System.out.print("P"+P[i]);if(i!=t-1){ System.out.print(""); } } System.out.println();returntrue; } } System.out.println("当前系统是不平安的，不存在平安序列");returnfalse; }publicstaticvoidmain(String[]args){try{ bankerb=newbanker(); b.Safe();for(inti=0;i<200;i++) b.Bank(); b.close(); }catch(Exceptione){ } }}运行结果实验三存储管理实验目的存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。本实验的目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。实验内容通过计算不同算法的命中率比拟算法的优劣。同时也考虑了用户内存容量对命中率的影响。 页面失效次数为每次访问相应指令时，该指令所对应的页不在内存中的次数。 在本实验中，假定页面大小为1k，用户虚存容量为32k，用户内存容量为4页到32页。produce_addstream通过随机数产生一个指令序列，共320条指令。指令的地址按下述原那么生成：50%的指令是顺序执行的25%的指令是均匀分布在前地址局部25%的指令是均匀分布在后地址局部具体的实施方法是：在[0，319]的指令地址之间随机选取一起点m；顺序执行一条指令，即执行地址为m+1的指令；在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m’；顺序执行一条指令，地址为m’+1的指令在后地址[m’+2，319]中随机选取一条指令并执行；重复上述步骤1〕~5〕，直到执行320次指令将指令序列变换称为页地址流在用户虚存中，按每k存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条~第9条指令为第0页〔对应虚存地址为[0，9]〕；第10条~第19条指令为第1页〔对应虚存地址为[10，19]〕；。。。。。。第310条~第319条指令为第31页〔对应虚存地址为[310，319]〕；按以上方式，用户指令可组成32页。计算并输出下属算法在不同内存容量下的命中率。先进先出的算法〔FIFO〕；最近最少使用算法〔LRU〕；最正确淘汰算法〔OPT〕；最少访问页面算法〔LFR〕；其中3〕和4〕为选择内容开始生成地址流开始生成地址流输入算法号S1≤S≤4形成地址页号用户内存空间msize=2Msize≤32OPT()FIFO()LRU()LFU()Msize加1S=?是否用其他算法继续结束NY1234YN提示出错，重新输入四、页面置换算法程序代码：package存储管理;importjava.util.Random;publicclassMemoryManage_Operation{private String[][]dataStrings=newString[33][4];//数据传递数组privateint[]Addstream=newint[320];//地址流privateint[]Addspage=newint[320];//页面流privateint[]phyBlock=newint[32];//物理块数privateRandomrandom=newRandom();//随机数privateintblockNum;//内存块数privateintnpageNum;//缺页数临时变量privatefloatrate;//缺页率privateinttempK,tempG,tempF;//临时变量//产生随机地址流和页面流publicvoidsetProduceAddstream(){inttemp;for(inti=0;i<320;i+=3){ temp=random.nextInt(320)%320+0;Addstream[i]=temp+1; temp=random.nextInt(320)%(Addstream[i]+1);Addstream[i+1]=temp+1; temp=random.nextInt(320)%(319-Addstream[i+1])+(Addstream[i+1]+1);if(i+2>=320){break; }Addstream[i+2]=temp; }for(inti=0;i<320;i++){Addspage[i]=Addstream[i]/10; } }//用户内存及相关数据初始化privatevoidinitialization(){for(inti=0;i<32;i++){phyBlock[i]=-1; }this.npageNum=0;this.rate=0;this.tempK=0;this.tempG=-1;this.tempF=-1; }publicvoidFIFO(){int[]time=newint[32];//定义进入内存时间长度数组intmax;//max表示进入内存时间最久的，即最先进去的 initialization();for(inti=0;i<blockNum;i++) time[i]=i+1;for(inti=0;i<320;i++) {this.tempK=0;for(intj=0;j<blockNum;j++)if(phyBlock[j]==Addspage[i]) {//表示内存中已有当前要调入的页面this.tempG=j;break; }for(intj=0;j<blockNum;j++)if(phyBlock[j]==-1){//用户内存中存在空的物理块this.tempF=j;break; }if(this.tempG!=-1)this.tempG=-1;else{if(this.tempF==-1) {//找到最先进入内存的页面 max=time[0];for(intj=0;j<blockNum;j++)if(time[j]>max){ max=time[j];this.tempK=j; }phyBlock[tempK]=Addspage[i]; time[tempK]=0;//该物理块中页面停留时间置零npageNum++;//缺页数+1 }else {phyBlock[tempF]=Addspage[i]; time[tempF]=0;npageNum++;tempF=-1; } }for(intj=0;j<blockNum&&phyBlock[j]!=-1;j++) time[j]++;//物理块中现有页面停留时间+1 }this.rate=1-(float)npageNum/320;dataStrings[blockNum][1]=this.rate+""; }publicvoidLRU(){int[]time=newint[32];intmax; initialization();for(inti=0;i<blockNum;i++) time[i]=i+1;for(inti=0;i<320;i++){tempK=0;for(intj=0;j<blockNum;j++)if(phyBlock[j]==Addspage[i]){this.tempG=j;break; }for(intj=0;j<blockNum;j++)if(phyBlock[j]==-1){this.tempF=j;break; }if(this.tempG!=-1){ time[tempG]=0;this.tempG=-1; }else{if(this.tempF==-1){ max=time[0];for(intj=0;j<blockNum;j++)if(time[j]>max){this.tempK=j; max=time[j]; }phyBlock[tempK]=Addspage[i]; time[tempK]=0;npageNum++; }else{phyBlock[tempF]=Addspage[i]; time[tempF]=0;npageNum++;this.tempF=-1; } }for(intj=0;j<blockNum&&phyBlock[j]!=-1;j++) time[j]++; }this.rate=1-(float)npageNum/320;dataStrings[blockNum][2]=this.rate+""; }publicvoidLFR(){ initialization();int[]time_lru=newint[32];int[]time=newint[32];intmin,max_lru,t;for(inti=0;i<blockNum;i++){ time[i]=0; time_lru[i]=i+1; }for(inti=0;i<320;i++){this.tempK=0; t=1;for(intj=0;j<blockNum;j++)if(phyBlock[j]==Addspage[i]){this.tempG=j;break; }for(intj=0;j<blockNum;j++)if(phyBlock[j]==-1){this.tempF=j;break; }if(this.tempG!=-1){ time_lru[tempG]=0;this.tempG=-1; }else{if(this.tempF==-1){if(i<=20){//将最少使用的间隔时间定位个单位 max_lru=time_lru[0];//在未到达“一定时间”的要求时，先采用LRU进行页面置换for(intj=0;j<blockNum;j++)if(time_lru[j]>max_lru){this.tempK=j; max_lru=time_lru[j]; }phyBlock[tempK]=Addspage[i]; time_lru[tempK]=0;npageNum++; }else{for(intj=0;j<blockNum;j++)//计算一定时间间隔内物理块中的页面使用次数for(inth=i-1;h>=i-1;h--)if(phyBlock[j]==Addspage[h]) time[j]++; min=time[0];for(intj=0;j<blockNum;j++)if(time[j]<min){ min=time[j];this.tempK=j; }for(intj=0;j<blockNum;j++)//应对出现页面使用次数同样少的情况if(time[j]==min) t++;if(t>1){//假设使用次数同样少，将次数相同的页面按照LRU进行页面置换 max_lru=time_lru[tempK];for(intj=0;j<blockNum&&time[j]==min;j++)if(time_lru[j]>max_lru){this.tempK=j; max_lru=time_lru[j]; } }phyBlock[tempK]=Addspage[i]; time_lru[tempK]=0;npageNum++; } }else{phyBlock[tempF]=Addspage[i]; time_lru[tempF]=0;npageNum++;tempF=-1; } }for(intj=0;j<blockNum&&phyBlock[j]!=-1;j++) time_lru[j]++; }this.rate=1-(float)npageNum/320;dataStrings[blockNum][3]=this.rate+""; }publicintgetBlockNum(){returnblockNum; }publicvoidsetBlockNum(intblockNum){this.blockNum=blockNum; }publicString[][]getDataStrings(){returndataStrings; }publicvoidsetDataStrings(String[][]dataStrings){this.dataStrings=dataStrings; }}package存储管理;importorg.eclipse.swt.widgets.Display;importorg.eclipse.swt.widgets.MessageBox;importorg.eclipse.swt.widgets.Shell;importorg.eclipse.swt.widgets.Menu;importorg.eclipse.swt.widgets.TableItem;importorg.eclipse.swt.SWT;importorg.eclipse.swt.widgets.MenuItem;importorg.eclipse.swt.widgets.Table;importorg.eclipse.swt.widgets.TableColumn;importorg.eclipse.swt.events.SelectionAdapter;importorg.eclipse.swt.events.SelectionEvent;publicclassManageSWT{ protectedShellshell; privateTabletable; publicstaticvoidmain(String[]args){ try{ ManageSWTwindow=newManageSWT(); window.open(); } catch(Exceptione){ e.printStackTrace(); } } publicvoidopen(){ Displaydisplay=Display.getDefault(); createContents(); shell.open(); shell.layout(); while(!shell.isDisposed()){ if(!display.readAndDispatch()){display.sleep();} } } protectedvoidcreateContents(){ shell=newShell(); shell.setSize(450,300); shell.setText("\u5B58\u50A8\u7BA1\u7406"); Menumenu=newMenu(shell,SWT.BAR); shell.setMenuBar(menu); MenuItemmenuItem=newMenuItem(menu,SWT.NONE); menuItem.addSelectionListener(newSelectionAdapter(){ @Override publicvoidwidgetSelected(SelectionEvente){ analysis(); } });menuItem.setText("\u547D\u4E2D\u7387\u5206\u6790"); MenuItemmenuItem_2=newMenuItem(menu,SWT.NONE); menuItem_2.addSelectionListener(newSelectionAdapter(){ @Override publicvoidwidgetSelected(SelectionEvente){ shell.dispose();} }); menuItem_2.setText("\u9000\u51FA"); MenuItemmenuItem_1=newMenuItem(menu,SWT.NONE); menuItem_1.addSelectionListener(newSelectionAdapter(){ @Override publicvoidwidgetSelected(SelectionEvente){ MessageBoxmessageBox=newMessageBox(shell,SWT.ICON_INFORMATION); messageBox.setText("关于"); messageBox.setMessage("存储管理"); messageBox.open(); } });menuItem_1.setText("\u5173\u4E8E"); table=newTable(shell,SWT.BORDER|SWT.FULL_SELECTION); table.setBounds(0,0,434,242); table.setHeaderVisible(true); table.setLinesVisible(true); TableColumntblclmnNewColumn=newTableColumn(table,SWT.NONE); tblclmnNewColumn.setWidth(90); tblclmnNewColumn.setText("\u7269\u7406\u5757\u6570"); TableColumntblclmnNewColumn_1=newTableColumn(table,SWT.CENTER); tblclmnNewColumn_1.setWidth(100); tblclmnNewColumn_1.setText("\u5148\u8FDB\u5148\u51FA\u7684\u7B97\u6CD5"); TableColumntblclmnNewColumn_2=newTableColumn(table,SWT.CENTER); tblclmnNewColumn_2.setWidth(110); tblclmnNewColumn_2.setText("\u6700\u8FD1\u6700\u5C11\u4F7F\u7528\u7B97\u6CD5"); TableColumntblclmnLfu=newTableColumn(table,SWT.CENTER); tblclmnLfu.setWidth(110); tblclmnLfu.setText("\u6700\u5C11\u8BBF\u95EE\u9875\u9762\u7B97\u6CD5"); } publicvoidanalysis(){ table.removeAll(); MemoryManage_OperationmOperation=newMemoryManage_Operation(); mOperation.setProduceAddstream(); String[][]tempStrings=newString[33][4]; for(inti=2;i<=32;i++){ mOperation.setBlockNum(i); tempStrings[i][0]=i+"K"; mOperation.FIFO(); mOperation.LRU(); mOperation.LFR(); tempStrings[i][1]=mOperation.getDataStrings()[i][1]; tempStrings[i][2]=mOperation.getDataStrings()[i][2]; tempStrings[i][3]=mOperation.getDataStrings()[i][3]; } for(inti=2;i<33;i++){ TableItemitem=newTableItem(table,SWT.NULL); for(intj=0;j<4;j++){ item.setText(j,tempStrings[i][j]); } } }}五、运行结果实验四磁盘调度实验目的：磁盘是高速、大容量、旋转型、可直接存取的存储设备。它作为计算机系统的辅助存储器，担负着繁重的输入输出工作，在现代计算机系统中往往同时会有假设干个要求访问磁盘的输入输出要求。系统可采用一种策略，尽可能按最正确次序执行访问磁盘的请求。由于磁盘访问时间主要受寻道时间T的影响，为此需要采用适宜的寻道算法，以降低寻道时间。本实验要求学生模拟设计一个磁盘调度程序，观察调度程序的动态运行过程。通过实验让学生理解和掌握磁盘调度的职能。实验题目：模拟电梯调度算法，对磁盘进行移臂操作提示及要求：假设磁盘只有一个盘面，并且磁盘是可移动头磁盘。磁盘是可供多个进程共享的存储设备，但一个磁盘每个时刻只能为一个进程效劳。当有进程在访问某个磁盘时，其它想访问该磁盘的进程必须等待，直到磁盘一次工作结束。当有多个进程提出输入输出请求而处于等待状态时，可用电梯调度算法从假设干个等待访问者中选择一个进程，让它访问磁盘。为此设置“驱动调度”进程。由于磁盘与处理器是并行工作的，所以当磁盘在为一个进程效劳时，占有处理器的其它进程可以提出使用磁盘〔这里我们只要求访问磁道〕，即动态申请访问磁道，为此设置“接受请求”进程。为了模拟以上两个进程的执行，可以考虑使用随机数来确定二者的允许顺序，程序结构图参考附图：“接受请求”进程建立一张“进程请求I/O”表，指出等待访问磁盘的进程要求访问的磁道，表的格式如下：进程名要求访问的磁道号“磁盘调度”的功能是查“请求I/O”表，当有等待访问的进程时，按电梯调度算法〔SCAN算法〕从中选择一个等待访问的进程，按其指定的要求访问磁道。SCAN算法参考课本第九章。算法模拟框图略。图1中的“初始化”工作包括：初始化“请求I/O”表，设置置当前移臂方向；当前磁道号。并且假设程序运行前“请求I/O”表中已有假设干进程〔4～8个〕申请访问相应磁道。实验报告：实验题目。程序中用到的数据结构及其说明。打印源程序并附注释。实验结果内容如下：打印“请求I/O”表，当前磁道号，移臂方向，被选中的进程名和其要求访问的磁道，看是否表达了电梯调度〔SCAN〕算法。体会与问题。附图：开始开始初始化磁盘调度随机数＞1/2继续？接受请求输入在[0，1]区间内的随机数结束六．磁盘调度的程序代码：package磁盘调度;publicclassCSCAN{publicintm=0;//用来存放磁头的初始位置publicbooleanRun=true;publicintsum=0;publicvoidCheck(inta[],intn,intposition){inttemp;for(inti=n;i>0;i--){//冒泡排序for(intj=0;j<i;j++){if(a[j]>a[j+1]){//按顺序依次比拟大小 temp=a[j];//把大的数字往前面放 a[j]=a[j+1]; a[j+1]=temp; } } }while(Run){for(inti=0;i<=n;i++){if(a[i]==position){m=i;Run=false; } } } System.out.println("CSCAN算法序列：");for(inti=m+1;i<=n;i++){//磁头向大号移动sum=sum+a[i]-a[i-1]; System.out.print(a[i]+""); }sum=sum+200-a[n];sum=sum+199;sum=sum+a[0]-1;for(inti=0;i<=m-1;i++){if(i!=m-1){sum=sum+a[i+1]-a[i]; } System.out.print(a[i]+""); } System.out.println(); System.out.println("寻道长度为"+sum); System.out.println("平均寻道长度为"+sum/n); } }package磁盘调度;publicclassSCAN{publicintm=0;//用来存放磁头的初始位置publicbooleanRun=true;publicintsum=0;publicvoidCheck(inta[],intn,intposition){inttemp;for(inti=n;i>0;i--)//冒泡排序 {for(intj=0;j<i;j++){if(a[j]>a[j+1])//按顺序依次比拟大小 { temp=a[j];//把大的数字往前面放 a[j]=a[j+1]; a[j+1]=temp; } } }while(Run){//此循环用来寻找磁头的初始位置被排到了什么位置for(inti=0;i<=n;i++){if(a[i]==position){m=i;Run=false; } } } System.out.println("SCAN算法序列：");for(inti=m+1;i<=n;i++){//磁头向大号移动sum=sum+a[i]-a[i-1]; System.out.print(a[i]+""); }sum=sum+200-a[n];sum=sum+200-a[m-1];for(inti=m-1;i>=0;i--){if(i!=0){sum=sum+a[i]-a[i-1]; } System.out.print(a[i]+""); } System.out.println(); System.out.println("寻到长度为"+sum); System.out.println("平均寻到长度为"+sum/n); }}package磁盘调度;publicclassSSTF{publicintm;//用来判断排序后磁头所在的初始位置的下标publicintb[];publicintrflag=0,lflag=0;publicdoubleSUM=0;publicintmleft,mright;publicSSTF(){b=newint[20]; }publicvoidCalculate(inta[],intn,intposition){inttemp;for(inti=n;i>0;i--)//冒泡排序 {for(intj=0;j<i;j++){if(a[j]>a[j+1])//按顺序依次比拟大小 { temp=a[j];//把大的数字往前面放 a[j]=a[j+1]; a[j+1]=temp; } } }if(a[n]==position){//如果磁头的初始位置在最大号 System.out.println("SSTF序列为：");for(inti=0;i<=n;i++){ System.out.print(a[i]+""); } }elseif(a[0]==position){ System.out.println("SSTF序列为：");for(inti=n;i>=0;i--){ System.out.print(a[i]+""); } }else{ System.out.println("SSTF序列为："); Check(a,n,position); } }publicvoidCheck(inta[],intn,intposition){booleanRun=true,Running=true;while(Run){//此循环用来寻找磁头的初始位置被排到了什么位置for(inti=0;i<=n;i++){if(a[i]==position){m=i; System.out.println("m的值为"+m);mleft=m-1;mright=m+1; Run=false; } } }while(Running){if(a[m]-a[mleft]>=a[mright]-a[m]&&rflag!=1){SUM=SUM+(a[mright]-a[m]);//用来统计寻到长度m=mright;mright++;if(mright>n){rflag=1; } System.out.print(a[m]+""); }elseif(a[m]-a[mleft]<a[mright]-a[m]&&lflag!=1){SUM=SUM+(a[m]-a[mleft]);m=mleft;mleft--;if(mleft<0){lflag=1; } System.out.print(a[m]+""); }if(mleft!=0&&mright>n){ Running=false;SUM=SUM+a[n]-a[mleft];for(intj=mleft;j>=0;j--){if(j!=0){SUM=SUM+a[j]-a[j-1]; } System.out.print(a[j]+""); } }if(mright!=n&&mleft<0){ Running=false;SUM=SUM+a[mright]-a[0];for(intk=mright;k<=n;k++){if(k!=0){SUM=SUM+a[k+1]-a[k]; } System.out.print(a[k]+""); } } } System.out.println(); System.out.println("sum的值为"+SUM); System.out.println("平均寻到长度为"+SUM/n); }}package磁盘调度;importjava.util.Scanner;publicclassDiskManage{publicstaticvoidmain(String[]args){inta[]=newint[20];intn=0;intm=0;doublesum=0;doubletemp=0;intposition=0; SSTFsstf=newSSTF(); SCANscan=newSCAN(); CSCANcscan=newCSCAN(); System.out.println("请输入磁盘请求的个数：");try{ Scannerreader=newScanner(System.in); n=reader.nextInt(); }catch(Exceptione){ } System.out.println("请输入磁盘请求序列："); Scannerreader=newScanner(System.in);for(inti=1;i<=n;i++){try{ a[i]=reader.nextInt(); }catch(Exceptione){ } } System.out.print("请输入磁头的初始位置：");try{ Scannerre=newScanner(System.in); a[0]=re.nextInt(); position=a[0]; }catch( System.out.println("磁头的初始位置为"+a[0]);for(inti=1;i<=n;i++){Exceptione){ } System.out.print(a[i]+""); } System.out.println("*****************************************************************"); System.out.println("提示：磁头的序列范围1~200！磁头从小号到大号寻道！"); System.out.println("请输入相应的选择操作：："); System.out.println("1、先来先效劳算法〔FCFS〕"); System.out.println("2、最短寻道时间优先算法〔SSTF〕"); System.out.println("3、扫描算法〔SCAN〕"); System.out.println("4、循环扫描算法〔CSCAN〕"); Scannerread=newScanner(System.in);try{ m=read.nextInt(); }catch(Exceptione){ } System.out.println("m的值为"+m); read.close();switch(m){case1: sum=0; System.out.println("FCFS算法序列：");for(inti=1;i<=n;i++){ System.out.print(a[i]+""); temp=a[i]-a[i-1];if(temp>=0);elseif(temp<0){ temp=-temp; } sum=sum+temp; } System.out.println(); System.out.println("sum的值为"+sum); System.out.println("平均寻到长度为"+sum/n);break;case2: sstf.Calculate(a,n,position);break;case3: scan.Check(a,n,position);break;case4: cscan.Check(a,n,position);break; }}}七．运行结果：FCFS：SCAN：SSTF：CSCAN：实验六模拟文件管理系统实验学时：2学时实验类型：设计实