操作系统实验报告java.docx
《操作系统实验报告java.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告java.docx（19页珍藏版）》请在冰豆网上搜索。
操作系统实验报告java
操作系统实验报告
院系：
专业：
班级：
学号：
姓名：
指导老师：
进程调度的模拟与内存管理
一、实验目的
在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就续进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
实验模拟实现处理机调度，以加深了解处理机调度的工作，并体会优先级和时间片轮转调度算法的具体实施方法。
帮助了解在不同的存储管理方式下，应怎样实现主存空间的分配和回收。
二、实验要求
1、可随机输入若干进程，并按优先权排序；
2、从就绪队首选进程运行：
优先权-1/要求运行时间-1
要求运行时间=0时，撤销该进程
3、重新排序，进行下轮调度。
4、可随时增加进程；
5、规定道数，设置后备队列和挂起状态。
若内存中进程少于规定道数，可自动从后备队列调度一作业进入。
被挂起进程入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列。
6、每次调度后，显示各进程状态。
7、自行假设主存空间大小，预设操作系统所占大小并构造未分分区表；
表目内容：
起址、长度、状态（未分/空表目）
8、结合以上实验，PCB增加为：
{PID，要求运行时间，优先权，状态，所需主存大小，主存起始位置，
PCB指针}
9、采用最先适应算法分配主存空间；
10、进程完成后，回收主存，并与相邻空闲分区合并。
11、采用图形界面；
三、实验内容
选择一个调度算法，实现处理机调度。
1、设计一个按优先权调度算法实现处理机调度的程序；
2、设计按时间片轮转实现处理机调度的程序。
3、主存储器空间的分配和回收。
在可变分区管理方式下，采用最先适应算法实现主存空间的分配和回收。
四、实验原理
该模拟系统采用java语言实现，要实现的功能有新建进程、进程调度、挂起进程、解挂进程、删除进程，道数和时间片大小可以由用户自己调整，有两种调度策略：
按优先权调度和按时间片轮转调度。
每个进程可能有5种状态：
新建（new）、就绪（ready）、运行（running）、阻塞（waiting）、挂起（suspend）。
每个状态都有一个队列用来存放处于该状态的进程，不同的调度策略采用不同的队列实现。
当创建进程时，如果内存中的进程数还没达到规定道数，则将新建进程插入就绪队列，如果内存中进程数已经达到规定道数，则插到后备队列，后备队列中的进程的状态为new。
CPU每次调度时都从就绪队列中取进程，在进程执行过程中如果下一个操作时IO操作，则将进程插入到waiting队列。
在系统运行过程中可以执行进程挂起操作，但执行的挂起操作时系统自动暂停运行，在弹出窗口选择要挂起的进程后，将选中的进程从原来的队列中删除并插入到挂起队列。
进行解挂操作时将选中的进程从挂起队列中删除并插入该进程原来所处的队列。
Ø按优先级调度：
当选择按优先权调度时，所有队列都采用优先队列，优先队列采用一个有序链表实现，进程的优先权值越大代表优先级越高，优先队列中的进程按优先权从大到小排列，当新进程插入时根据该进程的优先权插入到队列中的合适位置，插入后保持队列按优先权从大到小排列，如果新进程与队列中某个进程优先权值相等，则该新进程插到那个进程后面，以遵循先来先服务的规则。
当要从队列中取出进程时总是取队列中第一个进程，因为该进程的优先级最高。
Ø按时间片轮转调度：
当选择按时间片轮转调度时，所有队列都采用先进先出队列，先进先出队列采用一个普通单向链表实现，当新进程插入时插入到队列的末尾，当要取进程时取队首进程，这样就实现了先进先出。
Ø内存管理
该实验基于实验一完成，核心是内存的分配和回收，在实验一的基础上增加内存管理部分，在新建进程的时候增加一个输入内存大小的输入框，在进程进入内存时要分配内存，在进程销毁时要回收内存，如果进入内存时内存不足，则将进程插入到后备队列等待下次调度。
系统维护一个内存表，每个表项代表一个空间，每个空间保存了该空间的起始地址和空间大小以及空间使用状态。
初始时只有一个空间，当CPU启动时要分配内存，内存分配采用最先适应算法。
回收内存时如果有相邻空闲空间，则要进行空闲空间合并。
五、部分源程序
publicclassdata{
privateStringname;//进程的名字
privateinttime;//要求的时间总和
privateintpriority;//进程的优先权,值越大优先级越高
privateStringstate;//进程的状态
privateintstart;
privateintlength;//进程所占的内存空间
privateintisIn;//进程所需内存大小
Ø进程各项变量的初始化
publicvoidsetName（Stringname）{
this.name=name;
}
publicvoidsetPriority（intpriority）{
this.priority=priority;
}
publicvoidsetState（Stringstate）{
this.state=state;
}
publicStringgetName（）{
return（this.name）;
}
publicintgetPriority（）{
return（this.priority）;
}
publicStringgetState（）{
return（this.state）;
}
publicvoidsetTime（inttime）{
this.time=time;
}
publicintgetTime（）{
return（this.time）;
}
publicvoidsetLength（intlength）{
this.length=length;
}
publicintgetLength（）{
return（this.length）;
}
publicvoidsetStart（intstart）{
this.start=start;
}
publicintgetStart（）{
return（this.start）;
}
publicvoidsetIsIn（intisIn）{
this.isIn=isIn;
}
publicintgetIsIn（）{
return（this.isIn）;
}
Ø删除列表中第几个数据
publicvoidupdate（ArrayListlist,intnum）
{
sList.clear（）;
for（inti=0;i{
if（i!
=num）
{
sList.add（list.get（i））;
}
}
list.clear（）;
for（inti=0;i{
list.add（sList.get（i））;
}
}
publicvoidupdate1（ArrayListlist,intnum）
{
sList1.clear（）;
for（inti=0;i{
if（i!
=num）
{
sList1.add（list.get（i））;
}
}
list.clear（）;
for（inti=0;i{
list.add（sList1.get（i））;
}
}
Ø放入内存
publicvoidputInMemory（）
{
if（runningList.size（）>0）
{
if（runningList.get（0）.getIsIn（）==0）
{
for（inti=0;i{
if（unAssignList.get（i）.getLimit（）>=runningList.get（0）.getLength（））
{
runningList.get（0）.setStart（unAssignList.get（i）.getBase（））;
runningList.get（0）.setIsIn
（1）;
if（unAssignList.get（i）.getLimit（）==runningList.get（0）.getLength（））
{
update1（unAssignList,i）;
}
else
{
unAssignList.get（i）.setBase（unAssignList.get（i）.getBase（）+runningList.get（0）.getLength（））;
unAssignList.get（i）.setLimit（unAssignList.get（i）.getLimit（）-runningList.get（0）.getLength（））;
}
break;
}
}
}
}
if（readyList.size（）>0）
{
for（intj=0;j{
if（readyList.get（j）.getIsIn（）==0）
{
for（inti=0;i{
if（unAssignList.get（i）.getLimit（）>=readyList.get（j）.getLength（））
{
readyList.get（j）.setStart（unAssignList.get（i）.getBase（））;
readyList.get（j）.setIsIn
（1）;
if（unAssignList.get（i）.getLimit（）==readyList.get（j）.getLength（））
{
update1（unAssignList,i）;
}
else
{
unAssignList.get（i）.setBase（unAssignList.get（i）.getBase（）+readyList.get（j）.getLength（））;
unAssignList.get（i）.setLimit（unAssignList.get（i）.getLimit（）-readyList.get（j）.getLength（））;
}
break;
}
}
}
}
}
}
Ø移除内存
publicvoidputOutMemory（ArrayListlist,intnum）
{
list.get（num）.setIsIn（0）;
booleanflag1=false;
booleanflag2=false;
for（inti=0;i{
if（unAssignList.get（i）.getBase（）==（list.get（num）.getLength（）+list.get（num）.getStart（）））
{
unAssignList.get（i）.setBase（list.get（num）.getStart（））;
unAssignList.get（i）.setLimit（list.get（num）.getLength（）+unAssignList.get（i）.getLimit（））;
flag1=true;
break;
}
}
for（inti=0;i{
if（（unAssignList.get（i）.getBase（）+unAssignList.get（i）.getLimit（））==list.get（num）.getStart（））
{
if（!
flag1）
{
unAssignList.get（i）.setLimit（list.get（num）.getLength（）+unAssignList.get（i）.getLimit（））;
flag2=true;
break;
}
else
{
unAssignList.get（i）.setLimit（unAssignList.get（i）.getLimit（）+unAssignList.get（i+1）.getLimit（））;
update1（unAssignList,i+1）;
}
}
}
if（flag1||flag2）
{}
else
{
inti=0;
while（unAssignList.get（i）.getBase（）{
i++;
}
Data_Memorydata=newData_Memory（）;
data.setBase（list.get（num）.getStart（））;
data.setLimit（list.get（num）.getLength（））;
sList1.clear（）;
for（intj=0;j{
sList1.add（unAssignList.get（j））;
}
sList1.add（data）;
for（intj=i;j{
sList1.add（unAssignList.get（j））;
}
unAssignList.clear（）;
for（intj=0;j{
unAssignList.add（sList1.get（j））;
}
}
}
Ø对内存管理调度的操作
privateclassMyRendererextendsDefaultListCellRenderer
{
publicComponentgetListCellRendererComponent（JListlist,Objectvalue,intindex,booleanisSelected,booleancellHasFocus）
{
super.getListCellRendererComponent（list,value,index,isSelected,cellHasFocus）;
setBackground（Color.gray）;
for（inti=0;i{
for（intj=unAssignList.get（i）.getBase（）+6;j{
if（index==j）
{
setBackground（Color.white）;//当没有内容变为白色
}
}
}
returnthis;
}
}
publicvoidtimeManager（）
{
//去掉time==0的，从waiting队列加入新的进程，排序,调整waitingList加入runningLIst
//去掉time==0的
if（runningList.size（）>0）
if（runningList.get（0）.getTime（）==0）
runningList.clear（）;
sList.clear（）;
for（inti=0;i{
if（readyList.get（i）.getTime（）>0）
{
sList.add（readyList.get（i））;
}
}
readyList.clear（）;
for（inti=0;i{
readyList.add（sList.get（i））;
readyList.get（i）.setState（"ready"）;
}
//从waiting队列加入新的进程
intj=0;
intm=readyList.size（）;
for（;m<6&&j{
readyList.add（waitingList.get（j））;
readyList.get（m）.setState（"ready"）;
}
//sort（readyList）;
//调整waitingList
sList.clear（）;
for（inti=j;i{
sList.add（waitingList.get（i））;
}
waitingList.clear（）;
for（inti=0;i{
waitingList.add（sList.get（i））;
}
//加入runningLIst
if（runningList.size（）==0）
{
if（readyList.size（）>0）
{
runningList.add（readyList.get（0））;
runningList.get（0）.setState（"running"）;
update（readyList,0）;
if（waitingList.size（）>0）
{
readyList.add（waitingList.get（0））;
readyList.get（5）.setState（"ready"）;
}
update（waitingList,0）;
}
}
else//if（runningList.size（）>0）
{
if（readyList.size（）>0）
{
readyList.add（runningList.get（0））;
runningList.clear（）;
readyList.get（0）.setState（"running"）;
readyList.get（readyList.size（）-1）.setState（"ready"）;
runningList.add（readyList.get（0））;
update（readyList,0）;
}
}
putInMemory（）;
sub（）;
display（）;
jtf1.grabFocus（）;
}
publicvoidPManager（）
{
if（runningList.size（）>0）
if（runningList.get（0）.getTime（）==0）
runningList.clear（）;
sList.clear（）;
for（inti=0;i{
if（readyList.get（i）.getTime（）>0）
{
sList.add（readyList.get（i））;
}
}
readyList.clear（）;
for（inti=0;i{
readyList.add（sList.get（i））;
readyList.get（i）.setState（"ready"）;
}
intj=0;
intm=readyList.size（）;
for（;m<6&&j{
readyList.add（waitingList.get（getFirstW（waitingList）-1））;
readyList.get（m）.setState（"ready"）;
update（waitingList,getFirstW（waitingList）-1）;
}
//调整waitingList
//加入runningLIst
if（runningList.size（）==0）
{
if（readyList.size（）>0）
{
ru
升级会员 