进程控制模块操作系统进程控制课程设计Word文档下载推荐.docx

进程控制模块操作系统进程控制课程设计Word文档下载推荐.docx

《进程控制模块操作系统进程控制课程设计Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《进程控制模块操作系统进程控制课程设计Word文档下载推荐.docx（34页珍藏版）》请在冰豆网上搜索。

转到“优先级算法”，对就绪队列的进程按优先级降序排序；

7．voidautoModel（）:

进入自动模式，刷新按钮，启动线程；

8．voidrun（）:

线程类的线程函数，实现自动执行就绪队列中的进程，将时间片用完的进程再放回到就绪队列。

9．voidmanualModel（）:

进入手动模式的函数，刷新按钮。

10．voidcreateProcess（）:

创建进程，当创建进程的条件不满足时，提示错误，成功创建进程后，将进程按照先来先服务算法或优先级算法将进程添加到就绪队列，然后刷新就绪队列的表格。

11．paiXu（Processprocess）:

根据进程优先级算法，给就绪队列的进程排序,如果优先级相同，按先来先服务的方式排序；

12．voidrunProcess（）:

手动模式下，执行进程的函数，将就绪队列的第一进程取出执行，并显示正在被执行的进程。

13．voidreadyProcess（）:

手动模式下，让正在执行的进程结束执行，再放回到就绪队列。

14．voidblockProcess（）:

阻塞进程，将正在执行的进程阻塞，进程被阻塞后放到阻塞队列，然后刷新阻塞队列的表格。

15．voidwakeUpProcess（）:

唤醒阻塞队列里的第一个阻塞的进程，将唤醒的进程按照先来先服务的算法或者优先级算法放到就绪队列中，并刷新就绪队列的表格。

16．voidshutDownProcess（）:

终止进程，将正在执行的进程终止。

17．voidrefresh_ReadyList（）:

刷新就绪队列表格，把就绪队列里的就绪进程显示在就绪队列的表格中；

18．voidrefresh_BlockList（）:

刷新阻塞队列表格，把阻塞队列的阻塞进程显示在阻塞队列的表格中；

19．voidmain（Stringarg[]）:

主函数，库函数，JieMianjm=newJieMian（）;

实例化一个JieMian类的对象。

2.2.2.数据结构

包括数据结构的定义。

1．PCB的数据结构的定义:

//进程类

publicclassProcess{

publicStringname;

//进程名

publicinttime;

//时间

publicintpriority;

//进程优先级

publicintnum;

//轮转次数

publicStringgetName（）{

returnname;

}

publicvoidsetName（Stringname）{

this.name=name;

publicintgetTime（）{

returntime;

publicvoidsetTime（inttime）{

this.time=time;

publicintgetPriority（）{

returnpriority;

publicvoidsetPriority（intpriority）{

this.priority=priority;

publicintgetNum（）{

returnnum;

publicvoidsetNum（intnum）{

this.num=num;

}

2．就绪队列和阻塞队列的数据结构的定义

publicclassList{

staticLinkedList<

readyList=newLinkedList<

（）;

//就绪队列

blockList=newLinkedList<

//阻塞队列

2.2.3.算法

采用自然语言、流程图、N-S图、伪代码任一种描述。

步骤1、选择模式，否则不能开始程序；

步骤2、选择调度算法，否则不能创建进程；

事件1、创建进程；

（1）输入进程名字，名字要唯一，否则不能创建进程；

选择进程的时间片，默认时间片为1；

选择进程优先级，默认优先级为1；

（2）判断就绪队列是否为空，若不为空则不能创建进程；

（3）使用正则表达式验证进程名是否合法，否则不能创建进程；

（4）、创建进程成功，将进程插入就绪队列，并在就绪队列表格中显示。

事件2、执行进程；

（1）判断就绪队列是否为空，即是否有可执行的进程；

（2）、从就绪队列取出一个进程，赋值给runningProcess变量。

事件3、阻塞进程；

（1）判断是否有正在执行的进程；

（2）、判断阻塞队列是否已满；

（3）、满足阻塞条件，将正在执行的进程放入阻塞队列；

事件4、唤醒进程；

（1）判断是否有可唤醒的进程；

（2）判断就绪队列是否已满；

（3）按照已选择的调度算法，将被唤醒进程放入就绪队列，并刷新就绪队列表格，将进程移出阻塞队列。

事件5、终止进程；

判断是否有正在执行的进程，结束进程，令runningProcess=null；

3.系统实现

3.1.开发工具及语言

开发工具：

myeclipse

语言：

java

3.2.实现步骤

步骤一：

创建界面，初始化界面；

步骤二：

创建PCB，初始化PCB；

步骤三：

创建链表，初始化链表；

3.3.代码

importjava.awt.Color;

importjava.awt.Container;

importjava.awt.Font;

importjava.awt.GridLayout;

importjava.awt.event.ActionEvent;

importjava.awt.event.ActionListener;

importjava.awt.event.FocusAdapter;

importjava.awt.event.FocusEvent;

importjava.awt.event.FocusListener;

importjava.util.regex.Matcher;

importjava.util.regex.Pattern;

importjavax.swing.BorderFactory;

importjavax.swing.JButton;

importjavax.swing.JComboBox;

importjavax.swing.JFrame;

importjavax.swing.JLabel;

importjavax.swing.JOptionPane;

importjavax.swing.JPanel;

importjavax.swing.JScrollPane;

importjavax.swing.JTable;

importjavax.swing.JTextArea;

importjavax.swing.ListSelectionModel;

publicclassJieMianextendsThreadimplementsActionListener{

publicJFrameframe=newJFrame（）;

publicContainercont=frame.getContentPane（）;

publicJPaneltop_pan=newJPanel（）;

publicJPanelbottom_pan=newJPanel（）;

//放ready_pan、ready_pan

publicJPanelready_pan=newJPanel（newGridLayout（1,0））;

//放就绪队列表格的panel

publicJPanelblock_pan=newJPanel（newGridLayout（1,0））;

//放阻塞队列表格的panel

publicJLabeltop_lab=newJLabel（）;

publicJLabelsuanF_lab=newJLabel（）;

//显示采用的算法

publicJLabeltop_lab2=newJLabel（）;

publicJButtonconfirm_bn=newJButton（）;

publicJButtonready_bn=newJButton（）;

//就绪按钮

publicstaticJButtonshutdown_bn=newJButton（）;

//终止按钮

publicstaticJButtonrunn_bn=newJButton（）;

//执行按钮

publicJButtonblock_bn=newJButton（）;

//阻塞按钮

publicJButtonwakeUp_bn=newJButton（）;

publicJTextAreacreate_tx=newJTextArea（）;

//创建进程的文本框

publicJButtoncreate_bn=newJButton（）;

//创建进程的按钮

publicstaticJComboBoxset_auto_manual=newJComboBox（）;

//下拉框，选择模式

publicJLabelauto_manual_lab=newJLabel（）;

//标签

publicJComboBoxsuanFa=newJComboBox（）;

//下拉框，选择调度算法

publicJButtonsuanFa_bn=newJButton（）;

publicJComboBoxsdept_com=newJComboBox（）;

//下拉框，选择进程时间片

publicJLabeltime_lab=newJLabel（）;

publicJComboBoxpriority=newJComboBox（）;

//下拉框，选择进程优先级

publicJLabelpriority_lab=newJLabel（）;

//优先级标签

publicJComboBoxnum=newJComboBox（）;

//下拉框，选择进程轮转次数

publicJLabelnum_lab=newJLabel（）;

//轮转次数标签

publicJScrollPanescrollPane;

//滚动条

publicJTabletable;

//表格

publicString[]columnName={"

就绪队列"

"

优先级"

};

publicObject[][]data=newObject[12][2];

publicListSelectionModelcellSelectionModel;

//就绪队列的

publicListSelectionModelcellSelectionModel2;

//阻塞队列的

publicJScrollPanescrollPane2;

publicJTabletable2;

publicString[]columnName2={"

阻塞队列"

publicObject[][]data2=newObject[12][1];

//用于判断按钮是否需要刷新的变量

intmodel1=0;

//记录当前模式的前一个模式,0:

初始值；

1：

自动模式；

2：

手动模式

intmodel2=0;

//记录当前模

intalgorithm=0;

//记录选取的算法模式；

0:

先来先服务；

优先级算法

booleanflag=false;

//记录就绪队列是否为空

publicProcessrunningProcess=null;

//记录正在执行的进程

publicbooleanthreadFlag=false;

//记录线程是否在执行

publicbooleanrunStart=false;

//记录线程的run（）函数是否开始了

publicJieMian（）{

this.initframe（）;

@Override

publicvoidactionPerformed（ActionEvente）{

//TODOAuto-generatedmethodstub

JButtonbn=（JButton）e.getSource（）;

if（bn==confirm_bn）{

//选择手动模式或自动模式

this.selectModel（）;

}elseif（bn==suanFa_bn）{//选择算法

this.selectAlgorithm（）;

}elseif（bn==create_bn）{//创建进程

this.createProcess（）;

}elseif（bn==block_bn）{//阻塞进程

this.blockProcess（）;

}elseif（bn==wakeUp_bn）{//唤醒进程

this.wakeUpProcess（）;

}elseif（bn==shutdown_bn）{//终止进程

this.shutDownProcess（）;

}elseif（bn==runn_bn）{//执行进程

this.runProcess（）;

}elseif（bn==ready_bn）{//就绪

this.readyProcess（）;

}

//选择手动或自动模式

publicvoidselectModel（）{

create_bn.setEnabled（true）;

//JOptionPane.showMessageDialog（frame,"

选择模式"

asd"

JOptionPane.WARNING_MESSAGE）;

//判断自动模式还是手动模式

if（String.valueOf（（String）set_auto_manual.getSelectedItem（））.equals（"

自动"

））{//是自动模式

model1=model2;

model2=1;

if（model1==0||model1==2）{//第一次选择模式或者前一个模式是手动模式

this.autoModel（）;

}elseif（String.valueOf（（String）set_auto_manual.getSelectedItem（））.equals（"

手动"

））{

model2=2;

//手动模式

this.manualModel（）;

//选择算法

publicvoidselectAlgorithm（）{

if（String.valueOf（（String）suanFa.getSelectedItem（））.equals（"

先来先服务"

））{//是先来先服务算法

algorithm=1;

suanF_lab.setText（"

）;

}elseif（String.valueOf（（String）suanFa.getSelectedItem（））.equals（"

优先级算法"

algorithm=2;

if（List.readyList.size（）>

1）{//如果就绪队列不为空，调用排序函数

this.paiXu（）;

this.refresh_ReadyList（）;

}

//当"

转到“优先级算法”，对就绪队列按降序排序

publicvoidpaiXu（）{

Processprocess;

intn=List.readyList.size（）;

//得到就绪队列的长度

for（inti=1;

i<

=n-1;

i++）{//比较n-1轮

for（intj=0;

j<

=n-2;

j++）{

if（List.readyList.get（j）.getPriority（）<

List.readyList.get（j+1）.getPriority（））{

process=List.readyList.get（j）;

List.readyList.set（j,List.readyList.get（j+1））;

List.readyList.set（j+1,process）;

}

//进入自动模式

publicvoidautoModel（）{

System.out.println（"

进入自动模式"

//判断是否需要刷新按钮

if（model1!

=model2）{//需要刷新

wakeUp_bn.setEnabled（true）;

block_bn.setEnabled（true）;

shutdown_bn.setEnabled（false）;

ready_bn.setEnabled（false）;

runn_bn.setEnabled（false）;

if（runStart==false）{

this.start（）;

runStart=true;

退出了自动模式"

publicvoidrun（）{

threadFlag=true;

线程开始"

while（true）{System.out.println（"

"

//当就绪队列不为空,取出第一个进程执行

if（model2==1）{//是自动模式

if（flag）{//就绪队列不为空

try{

if（runningProcess!

=null）{//如果有正在被执行的进程,把进程加入到就绪队列

List.readyList.add（runningProcess）;

this.refresh_ReadyList（）;

//刷新就绪队列的表格

runningProcess=null;

}

runningProcess=List.readyList.getFirst（）;

//取出第一个就绪进程

top_lab2.setText（"

进程"

+runningProcess.getName（）+"

.exe正在执行"

System.out.println（runningProcess.getName（）+"

.exe"

+"

正在执行"

List.readyList.removeFirst（）;

//将第一个进程移出就绪队列

this.refresh_ReadyList（）;

Thread.sleep（runningProcess.getTime（）*1000）;

runningProcess.num--;

//将进程的轮转次数减一

if（runningProcess.num==0）{//如果轮转次数等于0，则结束进程

System.out.println（"

进程"

执行完毕"

if（model2!

=2）{//线程睡眠期间没有转换到手动模式

if（runningProcess!

=null）{//如果刚刚被执行的进程没有被阻塞，就加入到就绪队列

if（algorithm==2）{//如果采用了优先级算法，则调用排序函数

this.paiXu（runningProcess）;

}elseif（algorithm==1）{//如果采用的是先来先服务算法，则直接将进程添加到就绪队列

List.readyList.add（runningProcess）;

}

//List.readyList.add（runningProcess）;

this.refresh_ReadyList（）;

}

if（List.readyList.size（）==0）{//判断据需队列是否为空

flag=false;

top_lab2.setText（"

就绪队列为空"

}else{

fl