设备的分配与回收操作系统课程设计.docx
《设备的分配与回收操作系统课程设计.docx》由会员分享，可在线阅读，更多相关《设备的分配与回收操作系统课程设计.docx（27页珍藏版）》请在冰豆网上搜索。
设备的分配与回收操作系统课程设计
哈尔滨理工大学
课 程 设 计
（操作系统）
题 目：
设备的分配与回收
班 级：
计算机科学与技术学院计算机系 10-8班
姓 名：
陈俊鸣1004010820
指导教师：
高雪瑶
系主任：
林克正
2013年03月01日
目录
1生产者消费者问题课程设计1
1.1题目分析1
1.2数据结构1
1.3流程图1
1.4实现技术2
1.5设计结论和心得2
2Linux代码分析4
2.1功能说明4
2.2接口说明4
2.3局部数据结构4
2.4流程图4
2.5以实例说明运行过程5
1设备的分配与回收课程设计
1.1题目分析
在多到程序环境下，系统中的设备供所有进程共享。
为防止进程对系统资源的无序竞争，特规定系统设备不允许用户自行使用，必须由系统统一分配。
每当进程项系统提出I/O请求时，只要是可能和安全带，设备分配程序编按照一定的策略，吧设备分配给请求用户。
在有的系统中，为了确保在CPU与设备之间能进行通信，还应分配相应的控制器和通道。
为了实现设备分配，必须在系统中设置相应的数据结构。
1.2数据结构
设计中用到了Map（映射）的数据结构，Map结构包括了key和value两部分，通过key的匹配来查询value的值，符合次涉及到的要求，解决了四张表之间的关系
publicstaticMapmapD=newHashMap（）;
//对应DCT表的映射，key值为设备类型
publicstaticMapmapS=newHashMap（）;
//对用SDT的映射，key值为设备类型
publicstaticMapmapCO=newHashMap（）;
//对应COCT的映射，key值为控制器标识符
publicstaticMapmapCH=newHashMap（）;
//对应CHCT的映射，key值为通道标识符
publicstaticMythread[]mt=newMythread[3];
//允许申请3个进程，可根据需要做相应更改
以上4个映射用于存放对应表的信息，设计为全局静态是为了能存储文件和添加的设备、控制器、通道信息。
1.3流程图
实现设计中主程序和其他子模块的算法，以流程图的形式表示，需画出函数和过程的调用关系图。
文件读取Fileread（初始化）类
添加设备increase类
申请新进程increaseP类
Mythread类：
进程执行的方法
MainF类
1.4实现技术
在这次编程中，选择使用的是java是MyEclipse8.6拥有窗口的框架，但同时，由于java中没有指针的概念，使得SDT、DCT、COCT、CHCT之间的练习让我很头疼,所以我选择了使用映射map，映射中包含key和value，而key就好像C++中的指针的next，能将4张表练习到一起。
随后，在对进程的void方法中的设计令我认识到自己对java进程知识的掌握还很匮乏，现在还不能很好的运用sleep（）,wait（）,yield（）等方法，也不清楚其之间的区别，因此设计要求中的暂停无法很好的实现。
1.5设计结论和心得
这次编程，是我对设备的分配有了更进一步的了解，也是我的编译能力得到了锻炼。
通过本次课程设计，加深了对所学的操作系统的知识的理解，并且提高了自已的编程水平，也让自已认识到了自已编程中存在的问题，例如：
没有对系统做全面分析的习惯，以致于自已的程序没有把全部可能出现的情况考虑进内，以致于对于某一些特别的值，不能给出正确的运行结果，本次课程序设计认自已体会到了全面系统的分析问题的重要性和必要性。
多实践，多进行一些编程锻炼，这将成为我今后的一项课程，自己的编程水平还是太水，今后必须更加努力才行。
2.1Linux代码分析
为了进一步了解操作系统内核，学习了Linux操作系统的进程同步程序，主要程序源代码如下：
packagejframe;
importjava.io.BufferedReader;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importmap.CHCTmap;
importmap.COCTmap;
importmap.DCTmap;
importmap.SDTmap;
importtable.CHCT;
importtable.COCT;
importtable.DCT;
importtable.SDT;
/*文件读取代码
*
*/
publicclassFileread{
Stringfile="f:
//aa.txt";//文件的地址
Stringnext=null;//用来存放文件每行的信息
String[]s=newString[7];//将next值按空格分开后存到S数组中
SDTmapsm=newSDTmap（）;
DCTmapdm=newDCTmap（）;
COCTmapcom=newCOCTmap（）;
CHCTmapchm=newCHCTmap（）;
MainFmf=newMainF（）;
publicFileread（）{}
publicFileread（inti）throwsNumberFormatException,IOException{
try{
BufferedReaderinput=newBufferedReader（newInputStreamReader（newFileInputStream（file）））;//读文件
while（（next=input.readLine（））!
=null）{
Mythreadmyt=newMythread（）;
SDTsdt=newSDT（）;
DCTdct=newDCT（）;
COCTcoct=newCOCT（）;
CHCTchct=newCHCT（）;
s=next.split（""）;
sdt.settypeS（s[0]）;
sdt.setdeS（s[1]）;
dct.set（s[0],s[1],s[2]）;
coct.set（s[2],s[3]）;
chct.set（s[3],s[2]）;
myt.set（s[4],s[0],s[1],Double.valueOf（s[5]）,Double.valueOf（s[6]））;
mf.mt[mf.ii++]=myt;
sm.setmapS（s[0],sdt）;
dm.setmapD（s[0],dct）;
com.setmapCO（s[2],coct）;
chm.setmapCH（s[3],chct）;
//将读到的信息写入4张表对应的映射和进程数组中
}
}catch（FileNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
}
//添加设备的代码
Stringstr1=jTextField1.getText（）;//获得jTextField1中的信息
Stringstr2=jTextField2.getText（）;
Stringstr3=jTextField3.getText（）;
Stringstr4=jTextField4.getText（）;
SDTsdt=newSDT（）;
DCTdct=newDCT（）;
COCTcoct=newCOCT（）;
CHCTchct=newCHCT（）;
sdt.settypeS（str1）;
sdt.setdeS（str2）;
dct.set（str1,str2,str3）;
coct.set（str3,str4）;
chct.set（str4,str3）;
MainF.mapS.put（str1,sdt）;
MainF.mapD.put（str1,dct）;
MainF.mapCO.put（str3,coct）;
MainF.mapCH.put（str4,chct）;
this.dispose（）;//当前的窗口关闭
//申请新进程代码
Stringstr1=jTextField1.getText（）;
Stringstr2=jTextField2.getText（）;
Stringstr3=jTextField3.getText（）;
Stringstr4=jTextField4.getText（）;
Stringstr5=jTextField5.getText（）;
doubled1=Double.valueOf（str4）;
doubled2=Double.valueOf（str5）;
Mythreadmtt=newMythread（）;
mtt.set（str1,str2,str3,d1,d2）;
MainF.mt[MainF.ii++]=mtt;
this.dispose（）;
//进程代码
packagejframe;
importjava.io.IOException;
importjava.util.Iterator;
importjava.util.Map;
importjavax.swing.JTextArea;
importtable.CHCT;
importtable.COCT;
importtable.DCT;
importmap.CHCTmap;
importmap.COCTmap;
importmap.DCTmap;
importmap.SDTmap;
publicclassMythreadextendsThread{
SDTmapsm=newSDTmap（）;
Stringcon=null;//用来记录当前进程申请设备的控制器
Stringch=null;//用来记录当前进程申请设备的通道
DCTdct=newDCT（）;
COCTcoct=newCOCT（）;
CHCTchct=newCHCT（）;
Filereadfilr=newFileread（）;
Stringname;//记录进程名
doublestarttime,runtime;//记录进程的开始时间（会变）和执行时间
doubletime,use;//time用来记录进程的起始时间，use记录使用时间
Stringapptype;//记录进程要申请的设备类型
Stringappde;//设备标识符
Stringss="";//记录jtextArea要显示的信息
JTextAreatext;
publicvoidset（Stringname,Stringapptype,Stringappde,doublestarttime,doubleruntime）{
this.name=name;
this.apptype=apptype;
this.appde=appde;
this.starttime=starttime;
this.runtime=runtime;
}
publicvoidJT（JTextAreatext）{
this.text=text;
}
publicvoidsettime（doubletime）{
this.time=time;
}
publicvoidsetut（doubled）{
this.use=d;
}
publicvoidrun（）{
//判断要申请的设备是否存在，不存在进程沉睡999.999s
try{
dct=（DCT）filr.dm.getmapD（）.get（apptype）;
con=dct.get（）;
coct=（COCT）.getmapCO（）.get（con）;
ch=coct.get（）;
}catch（Exceptione）{
text.setText（"无该类设备"）;
try{
Thread.sleep（999999）;
}catch（InterruptedExceptione1）{
//TODOAuto-generatedcatchblock
e1.printStackTrace（）;
}
}
try{
Thread.sleep（（long）time*1000）;//进程在开始前睡眠
if（MainF.signal==1）{//signal为暂停标识符，为1是暂停30s
Thread.sleep（30000）;
MainF.signal=0;
}
text.setText（"阻塞中...."）;
Thread.sleep（（long）（starttime-time）*1000）;//阻塞时间
if（MainF.signal==1）{
Thread.sleep（30000）;
MainF.signal=0;
}
ss="进程"+name+"向"+"设备"+apptype+""+appde+"提出申请"+"\n"+"通过控制器：
"+con+"通道：
"+ch+"\n"
+"开始执行时间：
"+starttime+"\t"+"执行中.....";
text.setText（ss）;//jtextArea显示ss的信息
Thread.sleep（（long）runtime*1000）;//睡眠执行时间
if（MainF.signal==1）{
Thread.sleep（30000）;
MainF.signal=0;
}
ss="执行结束,使用时间"+use+""+"释放资源";
text.setText（ss）;
}catch（InterruptedExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
publicStringgetname（）{
returnname;
}
}
//主界面开始函数
inti=0;
intj=0;
intk=ii;//ii为全局静态变量，存储申请的进程数目
Mythreadmyt=null;
//冒泡排序，按开始时间升序排序进程
if（k>=2）{
for（i=0;ifor（j=i+1;jif（mt[i].starttime>mt[j].starttime）{
myt=mt[i];
mt[i]=mt[j];
mt[j]=myt;
}
}
}
}
//根据不同的进程数使用不同的方法
switch（ii）{
case1:
jTextArea2.setText（"该进程未使用"）;
mt[0].settime（mt[0].starttime）;
mt[0].setut（mt[0].runtime）;
mt[0].JT（jTextArea2）;
mt[0].start（）;
jTextArea3.setText（"该进程未使用"）;
jTextArea4.setText（"该进程未使用"）;
break;
case2:
jTextArea2.setText（"该进程未使用"）;
jTextArea3.setText（"该进程未使用"）;
jTextArea4.setText（"该进程未使用"）;
mt[0].settime（mt[0].starttime）;
mt[1].settime（mt[1].starttime）;
mt[0].setut（mt[0].runtime）;
mt[0].JT（jTextArea2）;
mt[0].start（）;
//判断是否阻塞，阻塞之后的方法
if（mt[0].apptype.equals（mt[1].apptype））{
if（（mt[0].starttime+mt[0].runtime）>mt[1].starttime）{
mt[1].starttime=mt[0].starttime+mt[0].runtime;
mt[1].setut（mt[1].starttime+mt[1].runtime-mt[1].time）;
mt[1].JT（jTextArea3）;
mt[1].start（）;
}
}else{
mt[1].setut（mt[1].runtime）;
mt[1].JT（jTextArea3）;
mt[1].start（）;
}
break;
case3:
jTextArea2.setText（"该进程未使用"）;
jTextArea3.setText（"该进程未使用"）;
jTextArea4.setText（"该进程未使用"）;
mt[0].settime（mt[0].starttime）;
mt[1].settime（mt[1].starttime）;
mt[2].settime（mt[2].starttime）;
mt[0].setut（mt[0].runtime）;
mt[0].JT（jTextArea2）;
mt[0].start（）;
if（mt[0].apptype.equals（mt[1].apptype））{
if（（mt[0].starttime+mt[0].runtime）>mt[1].starttime）{
mt[1].starttime=mt[0].starttime+mt[0].runtime;
mt[1].setut（mt[1].starttime+mt[1].runtime-mt[1].time）;
mt[1].JT（jTextArea3）;
mt[1].start（）;
}
}else{
mt[1].setut（mt[1].runtime）;
mt[1].JT（jTextArea3）;
mt[1].start（）;
}
try{
if（mt[0].apptype.equals（mt[2].apptype））{
if（（mt[0].starttime+mt[0].runtime）>mt[2].starttime）{
mt[2].starttime=mt[0].starttime+mt[0].runtime;
mt[2].setut（mt[2].starttime+mt[2].runtime-mt[2].time）;
mt[2].JT（jTextArea4）;
mt[2].start（）;
}
}else{
mt[2].setut（mt[2].runtime）;
mt[2].JT（jTextArea4）;
mt[2].start（）;
}
if（mt[1].apptype.equals（mt[2].apptype））{
if（（mt[1].starttime+mt[1].runtime）>mt[2].starttime）{
mt[2].starttime=mt[1].starttime+mt[1].runtime;
mt[2].setut（mt[2].starttime+mt[2].runtime-mt[2].time）;
mt[2].JT（jTextArea4）;
mt[2].start（）;
}
}else{
mt[2].setut（mt[2].runtime）;
mt[2].JT（jTextArea4）;
mt[2].start（）;
}
}catch（Exceptione）{
}
break;
}
}
2.2功能说明
2.3局部数据结构
publicstaticMapmapD=newHashMap（）;
//对应DCT表的映射，key值为设备类型
publicstaticMapmapS=newHashMap（）;
//对用SDT的映射，key值为设备类型
publicstaticMapmapCO=newHashMap（）;
//对应COCT的映射，key值为控制器标识符
publicstaticMapmapCH=newHashMap（）;
//对应CHCT的映射，key值为通道标识符
publicstaticMythread[]mt=newMythread[3];
//允许申请3个进程，可根据需要做相应更改
2.4本程序的流程图如图所示
2.5以实例说明运行过程
点击暂停可使系统暂停之心30s
添加新设备
申请新进程（申请的设备存在）
申请进程（申请的设备不存在）
升级会员 