2023年操作系统实验报告java

操作系统实验报告

院系:________________________________

专业：________________________________

班级：________________________________

学号:_________________________________

姓名:_________________________________

指导老师:_____________________________

进程调度的模拟与内存管理

一、实验目的

在采用多道程序设计的系统中，往往有若干个进程同时处在就绪状态。当

就续进程个数大于解决器数时,就必须依照某种策略来决定哪些进程优先占用解

决器。实验模拟实现解决机调度，以加深了解解决机调度的工作，并体会优先级

和时间片轮转调度算法的具体实行方法。帮助了解在不同的存储管理方式下，应

如何实现主存空间的分派和回收。

二、实验规定

1、可随机输入若干进程，并按优先权排序；

2、从就绪队首选进程运营：优先权-1/规定运营时间-1

规定运营时间=0时，撤消该进程

3、重新排序，进行下轮调度。

4、可随时增长进程；

5、规定道数，设立后备队列和挂起状态。若内存中进程少于规定道数，可

自动从后备队列调度一作业进入。被挂起进程入挂起队列，设立解挂功

能用于将指定挂起进程解挂入就绪队列。

6、每次调度后，显示各进程状态。

7、自行假设主存空间大小，预设操作系统所占大小并构造未分分区表；

表目内容：起址、长度、状态（未分/空表目）

8、结合以上实验，PCB增长为：

{PID,规定运营时间，优先权，状态，所需主存大小，主存起始位置，

PCB指针}

9、采用最先适应算法分派主存空间；

10、进程完毕后，回收主存，并与相邻空闲分区合并。

11、采用图形界面；

三、实验内容

选择一个调度算法，实现解决机调度。

1、设计一个按优先权调度算法实现解决机调度的程序；

2、设计准时间片轮转实现解决机调度的程序。

3、主存储器空间的分派和回收。在可变分区管理方式下，采用最先适应算

法实现主存空间的分派和回收。

四、实验原理

该模拟系统采用java语言实现，要实现的功能有新建进程、进程调度、挂

起进程、解挂进程、删除进程,道数和时间片大小可以由用户自己调整，有两种

调度策略:按优先权调度和准时间片轮转调度。每个进程也许有5种状态:新建(n

ew)、就绪(ready)、运营(running)、阻塞(waiting)^挂起(suspend)。

每个状态都有一个队列用来存放处在该状态的进程，不同的调度策略采用不同的

队列实现。当创建进程时，假如内存中的进程数还没达成规定道数，则将新建进程

插入就绪队列，假如内存中进程数已经达成规定道数，则插到后备队列,后备队

列中的进程的状态为new。CPU每次调度时都从就绪队列中取进程，在进程执

行过程中假如下一个操作时10操作，则将进程插入到waiting队列。在系统运

营过程中可以执行进程挂起操作，但执行的挂起操作时系统自动暂停运营，在弹出

窗口选择要挂起的进程后，将选中的进程从本来的队列中删除并插入到挂起队

列。进行解挂操作时将选中的进程从挂起队列中删除并插入该进程本来所处的队

列。

＞按优先级调度：

当选择按优先权调度时,所有队列都采用优先队列，优先队列采用一个有序

链表实现，进程的优先权值越大代表优先级越高，优先队列中的进程按优先权从

大到小排列，当新进程插入时根据该进程的优先权插入到队列中的合适位置，插

入后保持队列按优先权从大到小排列,假如新进程与队列中某个进程优先权值相

等，则该新进程插到那个进程后面,以遵循先来先服务的规则。当要从队列中取

出进程时总是取队列中第一个进程，由于该进程的优先级最高。

＞准时间片轮转调度：

当选择准时间片轮转调度时，所有队列都采用先进先出队列，先进先出队列

采用一个普通单向链表实现，当新进程插入时插入到队列的末尾，当要取进程时

取队首进程，这样就实现了先进先出。

＞内存管理

该实验基于实验一完毕，核心是内存的分派和回收，在实验一的基础上增长内

存管理部分，在新建进程的时候增长一个输入内存大小的输入框，在进程进入内存

时要分派内存，在进程销毁时要回收内存，假如进入内存时内存局限性，则将进程

插入到后备队列等待下次调度。系统维护一个内存表，每个表项代表一个空间，

每个空间保存了该空间的起始地址和空间大小以及空间使用状态。初始时只有一

个空间，当CPU启动时要分派内存，内存分派采用最先适应算法。回收内存时假

如有相邻空闲空间，则要进行空闲空间合并。

五、部分源程序

publicclassdata{

privateStringname；//进程的名字

privateinttime;//规定的时间总和

privateintpriority;//进程的优先权，值越大优先级越高

privateStringstate;//进程的状态

oprivateintstart：

oprivateintlength；//进程所占的内存空间

oprivateintisin;//进程所需内存大小

＞进程各项变量的初始化

publicvoidsetName(Stringname){

oothis.name=name;

0)

0

publievoidsetPriority(intpriority)

oothis.priority=priority;

o)

publicvoidsetState(Stringstate){

oothis.state=state;

)

publicStringgetName(){

oreturn(this,name)；

)

publieintgetPriority(){

return(this.priority);

0)

opub1icStringgetState(){

oreturn(this.state);

)

publicvoidsetTime(inttime){

othis.time=time;

)

pub1icintgetTime(){

©return(this.time);

)

pub1icvoidsetLength(int1ength)

oothis.Iength=1ength；

o)

opublicintgetLength(){

©return(this.length);

)

0

opublicvoidsetStart(intstart){

oothis.start=start;

o)

publieintgetStart(){

return(this.start)；

o)

opublievoidsetlsln(intisIn){

this.isln=isln；

0)

publicintgetIsIn(){

return(this.isln);

0)

>删除列表中第几个数据

publicvoidupdate(ArrayList<Data>list,intnum)

(

osList.c1ear()；

ofor(inti=0：i<list.size();i++)

0{

o©if(i!=num)

00{

osList.add(1ist.get(i));

000}

00}

olist.c1ear()；

o©for(inti=0;i<sList.size();i++)

0{

oolist.add(sList.get(i));

)

)

opublicvoidupdatel(ArrayList<Data_Memory>list,intnum)

0{

oosList1.clear();

ofor(inti=0；i<list.size()；i++)

o(

if(inum)

。0sListl.add(list.get(i));

)

0)

olist.clear();

ofor(inti=0;i<sList1.size()；i++)

{

©olist.add(sListl.get(i));

o)

)

>放入内存

publicvoidputinMemory()

0{

oif(runningList.size()>0)

0{

oif(runningList.get(0).getlsIn()==0)

000(

oofor(inti=0;i<unAssignList.size();i++)

0(

ooooif(unAssignList.get(i).getLimit()>=runningList.get(0).getLe

ngth())

0{

oooorunningList.get(0).setStart(unAssignList.get

(i).getBase());

ooooorunningList.get(0).setlsln(1);

oif(unAssignList.get(i).getLimit()==runningLis

t.get(O).getLength())

000(

ooooooupdatel(unAssignList,i)；

o}

oooelse

00{

oooounAssignList.get(i).setBase(unAssignList,get(i).g

etBase()+runningList.get(0).getLength())；

oooounAssignList.get(i).setLimit(unAssignList.get(i).g

etLimit()-runningList.get(0).getLength());

000)

ooobreak；

000)

00)

0)

00)

oif(readyList.size()>0)

0{

for(intj=0；j<readyList.size();j++)

00{

oooif(readyList.get(j).getIsin()==0)

00{

ooooofor(inti=0;i<unAssignList.size()；i++)

000(

ooif(unAssignList.get(i).getLimit()>=readyLis

t.get(j).getLength())

oooareadyLiSt.get(j).setStart(unAssignList.g

et(i).getBase())；

oQooreadyList.get(j).setIsln(1);

ooooif(unAssignList.get(i).getLimit()==readyLi

st.get(j).getLengthO)

000{

ooooooupdatel(unAssignListzi);

d00ooo)

oooooeIse

000(

oooounAssignList.get(i).setBase(unAssignList,g

et(i).getBase()+readyList.get(j).getLength());

ounAssignList.get(i).setLimit(unA

ssignList.get(i).getLimit()—readyList.get(j).getLength());

00000)

oobreak；

00)

0000)

000}

0)

0)

)

>移除内存

publicvoidputOutMemory(ArrayList<Data>list,intnum)

olist.get(num).setlsIn(0);

oobooleanf1ag1=false;

obooleanflag2=fa1se;

ofor(inti=0；i<unAssignList.size();i++)

0(

if(unAssignList.get(i).getBase()==(list.get(num).g

etLength()+list.get(num).getStart()))

(

ounAssignList.get(i).setBase(list.get(num).getStart());

oounAssignList.get(i).setLimit(list.get(num).getLengt

h()+unAssignList.get(i).getLimit());

oflag1=true；

ooobreak;

。)

o)

aofor(inti=0;i<unAssignList.size();i++)

0(

oif((unAssignList.get(i).getBase()+unAssignList.get(i).g

etLimit())==list.get(num).getStart())

00{

ooif(!flag1)

00{

©ounAssignList.get(i).setLimit(list,get(num).getLe

ngth()+unAssignList.get(i).getLimit())；

oooflag2=true；

break；

000)

oe1se

000\

ooounAssignList.get(i).setLimit(unAssignList.get(i).ge

tLimit()+unAssignList.get(i+1).getLimit());

oooooupdatel(unAssignList,i+1)；

o}

0}

0)

oif(flagl||flag2)

oo{}

e1se

00(

ooointi=0；

owhi1e(unAssignList.get(i).getBase()<1ist.get(num).g

etStart())

00(

ooi++;

00)

oData_Memorydata=newData_Memory()；

data.setBase(list.get(num).getstart());

odata.setLimit(list.get(num).getLength())；

osListl.c1ear()；

ofor(intj=0；j<i；j++)

00{

oooosList1.add(unAssignList,get(j));

。｝

osListl.add(data);

oaofor(intj=i;j<unAssignList.size();j++)

00{

oosList1.add(unAssignList.get(j));

O0}

ounAssignList.clear();

oofor(intj=0;j<sList1.size();j++)

0{

©ounAssignList,add(sListl.get(j));

o}

00

0o)

0

o)

>对内存管理调度的操作

privateclassMyRendererextendsDefau1tListCellRenderer

(

pub1icComponentgetListCellRendererComponent(JList

list,Objectvalue,intindex,booleanisSelected,b0olean

cellHasFocus)

0(

oosuper.getListCe11RendererComponent(1ist,va1ue

index,isSelected,ceHHasFocus)；

oosetBackground(Co10r.gray)；

for(inti=0;i<unAssignList.size();i++)

ofor(intj=unAssignList.get(i).getBase()+6;j<u

nAssignList.get(i).getLimit()+unAssignList.get(i).getBase()+6;

j++)

{

ooif(index==j)

0o(

ooooosetBackground(Color.white);//当没有内容变为白色

0000)

00)

。)

oreturnthis;

0)

0}

publievoidtimeManager()

(

o〃去掉time==0的，从waiting队歹力口入新的进程，排厅，调整waitingList力口

ArunningLIst

0

0〃去掉time==o的

ooif(runningList.size()>0)

oif(runningList.get(0).getTime()==0)

oo©runningList.clear();

osList.c1ear();

ofor(inti=0;i<readyList.size();i++)

o(

oif(readyList.get(i).getTime()>0)

00{

osList.add(readyList.get(i));

)

}

oreadyList.clear();

oofor(inti=0;i<sList.size();i++)

0(

readyList.add(sList.get(i));

readyList.get(i).setState(Hready”)；

o)

o//从waiting队列加入新的进程

ointj=0；

intm=readyList.size();

oofor(；m<6&&j<waitingList.size();m++,j++)

00{

oooreadyList.add(waitingList.get(j))；

oreadyList.get(m).setstate("readyH);

o)

ooo//sort(readyList)；

o//调整waitingList

sList.clear();

ofor(inti=j；i<waitingList.size();i++)

0(

sList.add(waitingList.get(i))；o

}

owaitingList.clear()；

for(inti=0;i<sList.size();i++)

waitingList.add(sList.get(i))；

0}

//力口入runningList

if(runningList.Size()==0)

(

oif(readyList.size()>0)

o(

orunningList.add(readyList.get(0))；

orunningList.get(0).setstate("running11)；

update(readyList,0);

oif(waitingList.size()>0)

o(

readyList.add(waitingList.get(0))；

ooreadyList.get(5).setstate(”readyM);

00}

oooupdate(waitingListz0);

o)

0

)

e1se//if(runningList.size()>0)

ooif(readyList.size()>0)

oooreadyList.add(runningList.get(0));

orunningList.clear()；

ooreadyList.get(0).setState("running");

oo©readyList.get(readyList.size()-1).setState(nready'*);

runningList.add(readyList.get(0))；

oooupdate(readyListz0);

0)

0

)

putInMemory();

osub()；

odisplay()；

ojtf1,grabFocus();

o)

opublicvoidPManager()

00{

ooif(runningList.size()>0)

ooif(runningList.get(0).getTime()==0)

ooarunningList.clear()；

osList.clear()；

oofor(inti=0;i<readyList.size();i++)

0

ooif(readyList.get(i).getTime()>0)

ooosList.add(readyList.get(i));

0o}

000)

oreadyList.clear()；

for(inti=0;i<sList.size();i4-+)

00{

oooreadyList.add(sList.get(i));

ooreadyList.get(i).setState(nreadyn);

000)

ointj=0;

intm=readyList.size()；

o©for(；m<6&&j<waitingList,size();m++,j++)

000{

ooreadyList.add(waitingList.get(getFirstW(wa

itingList)-1));

Hn

ooreadyList.get(m).setState(ready)；

oooupdate(waitingListzgetFirstW(waitingList)-1);

o}

00o//调整waitingList

0

oo//力口入runningL工st

o©if(runningList.size()==0)

00o{

if(readyList.size()>0)

00runningList.add(readyList.get(getFirstW(readyLi

st)-1));

oorunningList.get(0).setState(nrunning");

oooupdate(readyListzgetFirstW(readyList)-1);

oif(waitingList.size()>0)

00000{

oreadyList.add(waitingList.get(getFirstW

(waitingList)-1))；

ooreadyList.get(readyList,size()-1).setState(n

readyn);

o)

oooupdate(waitingList,getFirstW(waitingList)-1);

000)

0)

ooe1S6

0(

ooif(readyList.size()>0)

o(

oobooleanflag=false；

oointa=runningList.get(0).getPriority()；

ooointb=readyList.get(getFirstW(readyList)-1).ge

tPriority();

oif(a>b)

000{

ooosList.clear();

osList.add(readyList.get(getFirstW(readyLis

)-1));

ooflag=true;

00}

00

oooif(flag)

o(

oorunningList.get(0).setState("ready");

ooreadyList.add(runningList.get(0))；

oorunningList.c1ear()；

ooorunningList.add(sList.get(0));

oorunningList.get(0).setstate(Hrunningn);

ooupdate(readyListzgetFirstW(readyList)-1);

00)

)

0

o)

putInMemory();

osubl();

display()；

ojtf1.grabFocus();

}

六、程序运营图

图1进程界面

BCPU调度及内存管理nx

进程名称：进程运行时间:内存状态;

0

1

迸程忧先皴:进程大小:2

3

4

StartPrioritystopStartTime5

6

7-

运行队列：后备以列：挂起队列：8

9

110

111

112

11仰3

I15

I16

I17

I18

I19

I20

I21

I22

I23

I24

I25

I26

I27

I28

I29

I30

I31

I32

I33

挂起waiting进程▼解挂结束waiting进程▼I34

I35

I346

图2新建进程

BCPU调度及内存管理i|n

进程名称:迸程运行时间:

迸程优先级:迸程大小:

StartPrioritystopStartTimestop

运行队列:挂起队列:

名称|ME…|时间|优先|起始|大小K日优先起始大小

无…