动态优先级算法文档格式.docx
《动态优先级算法文档格式.docx》由会员分享，可在线阅读，更多相关《动态优先级算法文档格式.docx（25页珍藏版）》请在冰豆网上搜索。
（1）了解并掌握文件系统中用于管理所必须的数据结构。
（2）了解并掌握主要的文件操作命令的实现方法。
（3）通过课程实践掌握课程设计的方法和流程，并总结设计经验，提出更好的改进方法。
2.课程设计任务及要求
2.1设计任务
在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个，且进程之间也存在着同步与互斥的关系，要求采用指定的调度策略，使系统中的进程有条不紊地工作，通过观察诸进程的运行过程，以巩固和加深处理机调度的概念
2.2设计要求
每一个进程有一个PCB，其内容可以根据具体情况设定。
可以在界面设定的互斥资源（包括两种：
输入设备与输出设备）的数目
进程数、进入内存时间、要求服务时间可以在界面上进行设定
进程之间存在一定的同步与互斥关系，可以通过界面进行设定，其表示方法如下：
进程的服务时间由三段组成：
I2C10O5（表示进程的服务时间由2个时间片的输入，10个时间片的计算，5个时间片的输出）
进程间的同步关系用一个段表示：
W2，表示该进程先要等待P2进程执行结束后才可以运行
因此，进程间的同步与互斥关系、服务时间可以统一用四段表示为：
I2C10O5W2
可以在运行中显示各进程的状态：
就绪、阻塞、执行
采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相应的阻塞队列
具有一定的数据容错性
3.算法及数据结构
3.1算法总体设计思想
动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变，以便获得更好的调度性能。
例如，我们可以规定，在就绪队列中的进程，随其等待时间的增长，其优先权以速率a提高。
若所有的进程都有相同的优先权初始值则显然是最先进入就绪队列的进程将因其动态优先权变得最高而优先获得处理机，此即FCFS算法。
若所有的就绪队列进程具有各不相同的优先权初始值，那么，对于优先权初始值低的进程，在等待足够的时间后，其优先权便可能升为最高从而获得处理机。
而采用抢占式调度算法时，如果再规定当前进程的优先权以速率b下降，则可防止一个长作业长期地垄断处理机。
3.2动态优先级算法
3.2.1功能
最高响应比优先法（HRRN）是对FCFS方式和SJF
方式的一种综合平衡。
HRRN调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。
响应比R定义如下：
R=（W+T）/T=1+W/T
其中T为该作业估计需要的执行时间，W为作业在后备状态队列中的等待时间。
每当要进行作业调度时，系统计算每个作业的响应比，选择其中R最大者投入执行。
这样，即使是长作业，随着它等待时间的增加，W/T也就随着增加，也就有机会获得调度执行。
这种算法是介于FCFS和SJF
之间的一种折中算法。
由于长作业也有机会投入运行，在同一时间内处理的作业数显然要少于SJF
法，从而采用HRRN
方式时其吞吐量将小于采用SJF
法时的吞吐量。
另外，由于每次调度前要计算响应比，系统开销也要相应增加。
3.2.2数据结构
floatarrtime[];
//作业到达时间
floatinputtime[];
////输入时间
floatcputime[];
//CPU运行时间
floatoutputtime[];
//输出时间
floatwaittime[];
//等待时间
floatinstatime[];
//开始运行时间
floatcpustatime[];
//CPU开始时间
floatoutstatime[];
//输出开始时间
floatfintime[];
//结束运行时间
floatprio[];
//优先权
Stringstate[];
//是否已经完成
intarrival[];
//是否到达
intinputdone[];
//是否输入完成
intinputown[];
//是否分配输入设备
intcpudone[];
//是否运行完成
intcpuown[];
//是否分配内存
intoutputdone[];
//是否输出完成
intoutputown[];
//是否分配输出设备
intwaitpro[];
//等待的进程号
3.2.3算法流程图
图3.4CSCAN算法流程图
4.程序设计与实现
4.1系统流程图
图4.1系统流程图
4.2程序代码
importjava.awt.*;
importjava.awt.event.*;
importjava.util.*;
importjavax.swing.*;
importjavax.swing.table.DefaultTableModel;
importjavax.swing.table.JTableHeader;
publicclassStopWatchimplementsActionListener{
floatarrtime[];
/**秒表线程启动控制*/
publicbooleanisRun=false;
/**记录开始时间*/
privatelongstarTime;
/**记录暂停时间*/
privatelongstopTime;
/**记录暂停到继续的总时间*/
privatelongwasteTime;
/**基于Frame的窗口*/
privateJFramestopWatchFrame;
privateJButtonstarButton;
privateJButtonstopButton;
privateJButtoncontinueButton;
JLabelTIME=newJLabel（"
"
）;
JLabelWAIT=newJLabel（"
等待的进程↓"
JLabelBEIW=newJLabel（"
被等的进程↓"
JLabelidl=newJLabel（"
输入设备↓"
JLabelodl=newJLabel（"
输出设备↓"
JLabelpl=newJLabel（"
进程数↓"
JPanelp1=newJPanel（）;
intMAXPRO;
//最大数量的进程数
intIDMAX,ODMAX;
//输入、输出设备
JTabletable;
TextFieldbeideng=newTextField（）;
//
TextFielddeng=newTextField（）;
TextFieldID=newTextField（）;
TextFieldOD=newTextField（）;
TextFieldMAXP=newTextField（）;
JButtonEnter=newJButton（"
确定"
/**创建一个基于Frame的窗口.其中显示一个秒表（时:
分:
秒:
毫秒），还有“开始”“暂停“继续“停止”新建秒表”按钮*/
publicStopWatch（inti,intidmax,intodmax）{
MAXPRO=i;
IDMAX=idmax;
ODMAX=odmax;
arrtime=newfloat[i];
inputtime=newfloat[i];
cputime=newfloat[i];
outputtime=newfloat[i];
fintime=newfloat[i];
prio=newfloat[i];
waittime=newfloat[i];
instatime=newfloat[i];
cpustatime=newfloat[i];
outstatime=newfloat[i];
state=newString[i];
arrival=newint[i];
inputdone=newint[i];
inputown=newint[i];
cpudone=newint[i];
cpuown=newint[i];
outputdone=newint[i];
outputown=newint[i];
waitpro=newint[i];
Randomrnd=newRandom（）;
for（intj=0;
j<
i;
j++）{//初始化数量
arrtime[j]=rnd.nextFloat（）*5;
inputtime[j]=rnd.nextFloat（）*5;
cputime[j]=rnd.nextFloat（）*5;
outputtime[j]=rnd.nextFloat（）*5;
fintime[j]=0;
prio[j]=rnd.nextFloat（）*5;
waitpro[j]=0;
instatime[j]=0;
cpustatime[j]=0;
outstatime[j]=0;
state[j]="
READY"
;
arrival[j]=0;
inputdone[j]=0;
inputown[j]=0;
cpudone[j]=0;
cpuown[j]=0;
outputdone[j]=0;
outputown[j]=0;
}
ID.setText（IDMAX+"
OD.setText（ODMAX+"
MAXP.setText（MAXPRO+"
ID.setEditable（false）;
OD.setEditable（false）;
MAXP.setEditable（false）;
TIME.setBounds（80,0,70,70）;
p1.setLayout（null）;
stopWatchFrame=newJFrame（"
StopWatch"
starButton=newJButton（"
开始"
stopButton=newJButton（"
暂停"
continueButton=newJButton（"
继续"
stopWatchFrame.addWindowListener（newWindowAdapter（）//关闭窗口程序
{
publicvoidwindowClosing（WindowEvente）{
System.exit（0）;
}
}）;
TIME.setBounds（80,0,200,70）;
//设置位置大小
BEIW.setBounds（80,0,200,70）;
WAIT.setBounds（80,0,200,70）;
starButton.setBounds（0,80,75,25）;
stopButton.setBounds（80,80,75,25）;
beideng.setBounds（600,80,75,25）;
deng.setBounds（680,80,75,25）;
WAIT.setBounds（680,40,200,25）;
BEIW.setBounds（600,40,100,25）;
Enter.setBounds（760,80,75,25）;
ID.setBounds（240,80,75,25）;
OD.setBounds（320,80,75,25）;
MAXP.setBounds（400,80,75,25）;
odl.setBounds（320,40,75,25）;
idl.setBounds（240,40,75,25）;
pl.setBounds（400,40,75,25）;
continueButton.setBounds（160,80,75,25）;
starButton.addActionListener（this）;
//按钮添加监听器
stopButton.addActionListener（this）;
continueButton.addActionListener（this）;
p1.setBounds（0,0,1000,700）;
p1.add（idl）;
p1.add（odl）;
p1.add（pl）;
p1.add（ID）;
p1.add（OD）;
p1.add（MAXP）;
p1.add（BEIW）;
p1.add（WAIT）;
p1.add（TIME）;
p1.add（beideng）;
p1.add（deng）;
p1.add（Enter）;
p1.add（starButton）;
//将按钮加进面板中
p1.add（stopButton）;
p1.add（continueButton）;
stopWatchFrame.setLayout（null）;
stopWatchFrame.add（p1）;
//将面板加进窗口
stopWatchFrame.setVisible（true）;
//显示窗口
stopWatchFrame.setSize（1000,600）;
Enter.addActionListener（newActionListener（）{
publicvoidactionPerformed（ActionEvente）{
Integer.parseInt（deng.getText（））;
Integer.parseInt（beideng.getText（））;
waitpro[Integer.parseInt（deng.getText（））-1]=Integer
.parseInt（beideng.getText（））;
JOptionPane.showMessageDialog（null,"
添加成功"
"
请确认"
JOptionPane.INFORMATION_MESSAGE）;
}
}
}）;
}
/**按钮响应，当按下“开始”按钮时，秒表开始计时，按下暂停时暂停及时，按下继续时接着计时，只至按下“停止”按钮*/
publicvoidactionPerformed（ActionEvente）{
watchRunwatch=newwatchRun（）;
ThreadwatchThread=newThread（watch）;
//产生一个秒表线程
Objectobj=e.getSource（）;
//返回：
最初发生Event的对象
Enter.setEnabled（false）;
if（obj==starButton）//对象为开始按钮时
{
if（!
isRun）{
isRun=true;
starTime=System.currentTimeMillis（）;
watchThread.start（）;
}elseif（obj==stopButton）//对象为暂停按钮时
if（isRun）{
isRun=false;
stopTime=System.currentTimeMillis（）;
elseif（obj==continueButton）//对象为继续按钮时
wasteTime=wasteTime+System.currentTimeMillis（）-stopTime;
/***************************************************************************
*实现表格
*
*/
/**秒表线程类实现Runnable接口*/
publicclasswatchRunimplementsRunnable{
publicvoidrun（）{
intmsec=0;
intsecond=0;
intminute=0;
inthour=0;
Stringbiaotou[]={"
进程号"
输入开始"
输入结束"
cpu开始"
CPU结束"
"
输出开始"
输出结束"
优先级"
状态"
};
Object[][]playerInfo=newObject[MAXPRO][9];
for（inti1=0;
i1<
MAXPRO;
i1++）
playerInfo[i1][0]=i1+1;
table=newJTable（playerInfo,biaotou）;
table.setAutoResizeMode（JTable.AUTO_RESIZE_OFF）;
table.getTableHeader（）.setReorderingAllowed（false）;
table.setBounds（20,150,400,250）;
table.setEnabled（false）;
table.setBackground（newColor（250,250,250））;
table.getTableHeader（）.setResizingAllowed（false）;
JScrollPanescroll=newJScrollPane（table）;
scroll.setBounds（20,150,800,500）;
table.setPreferredScrollableViewportSize（newDimension（550,100））;
stopWatchFrame.add（scroll）;
while（isRun）//线程执行
{
table.repaint（）;
for（intyanyu=0;
yanyu<
yanyu++）
playerInfo[yanyu][7]=prio[yanyu];
intcount;
Stringstr="
count=（int）（System.currentTimeMillis（）-starTime-wasteTime）;
second=（int）（（count-hour*3600000-minute*60000）/1000）;
str=second+"
/*************************************/
intquantity;
//进程数量
intquantity2;
intid=IDMAX;
//输入进程的数量
floatm0,m1;
//时间
intnum;
//等待进程
intcurrentcpu=0;
//CPU是否忙碌
intk;
intc=1;
//默认CPU当前可用
floatn;
intod=ODMAX;
//输出设备
intl;
floatp;
for（quantity=0;
quantity<
quantity++）{
if（arrtime[quantity]<
=second）/
升级会员 