收藏小站
操作系统实验-CPU进程调度和内存分配 - java版 下载本文

操作系统实验

第一期 项目开发实现

实验名称 EXP.1 CPU Scheduling

Exp.2 Allocation & Reclaim

实验内容

一，选择一个调度算法，实现处理机调度；

二，处理机调度过程中，主存储器空间的分配和回收；

实验目的

一,多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。本实验模拟实现处理机调度，以加深了解处理机调度的工作；

二，帮助了解在不同的存储管理方式下，应怎样实现主存空间的分配和回收；

实验题目

一，（1）设计一个按照优先权调度算法实现处理机调度的程序； （2）设计按时间片轮转实现处理机调度的程序；

二，在可变分区管理方式下，采用最先适应算法实现主存空间的分配和回收；

实验要求

一，（a），PCB内容： 进程名/PID； 要求运行时间（单位时间）； 优先权； 状态； PCB指针； ——(因课程内容原因，这个指针在设计中没用)

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

2，从就绪队列首选进程运行：优先权-1/ 要求运行时间-1；要求运行时间=0时，

撤销该进程；

3，重新排序，进行下一轮调度； （b），最好采用图形界面；

（c）,可随时增加进程；

（d），规定道数，设置后备队列和挂起状态。若内存中进程数少于规定道数，可自动从后备队列调度一作业进入。被挂起进程如=入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列；

（e），每次调度后，显示各进程状态；

二，（a），自行假设主存空间大小，预设操作系统所占大小并构造未分分区表； 表目内容：起址、长度、状态（未分/空表目）

（b），结合实验一，PCB增加为：｛PID，要求运行时间，优先权，状态，所需内存大

小，主存起始位置，PCB指针（失效）｝； （C）采用最先适应算法分配主存空间；

（D），进程完成后，回收主存，并与相邻空闲分区合并；

实验过程及分析

1，

初步设计：

2， 详细设计：

（1）作业进入内存中，由CPU分配产生PCB属性，并通过PCB记录进程状态，实验即以PCB代表进程模拟调度过程；

（2）在多道系统中，多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机，本实验采用优先级；

（3），进程调度时，规定若就绪队列进程数少于6个，则自动从后备队列调入一个作业；

（4），系统会将占有较多资源、预期结果不符合要求的进程自动挂起，并回收所占资源，而本实验设置为手动挂起；

（5），在适宜条件下，系统会将挂起的进程自动解挂，而且只解挂到就绪队列；本实验为简化操作，设置为手动解挂，若解挂条件合适（即CPU各种资源可用），则解挂到就绪队列，并分配内存；若解挂条件不适宜，则解挂至后备队列，但不分配内存（实际上这是不对的，因为作业进入内存，由CPU标记PCB后，不能撤销PCB再返回内存，除非该进程执行结束，但本程序为体现解挂的意思，还是错误地设计为可以解挂到后备队列，读者需注意，这个功能可以在代码中注销，另外也希望有高手可以改进）；

（b），实验程序设计：

（1），本实验采用java语言编程，并实现GUI界面显示；

（a），操作系统知识回顾：

（2），为体现java语言面对对象程序设计的特点，实验设计为ProcessPCB、MemoryItem类封装PCB和所分配的内存各自的属性与方法；用ProcessRecords、MemoryRecords类封装数组方法；用SingleCPUScheduling实现GUI界面显示； （3），ProcessPCB类中，定义PCB的进程名、要求运行时间、优先级、状态、主存起始位置、所需内存大小这6个属性，并定义各属性的get和set方法，定义equals方法用于对比类的属性，定义toString方法得到类属性的字符串，定义run方法封装优先权-1/ 要求运行时间-1的过程；MemoryItem类中，定义可分分区表每一可分记录的主存起始位置、内存大小及其get和set方法，定义toString方法得到可在界面显示的字符串；

（4），ProcessRecords封装PCB数组的添加元素addItem和删除元素removeItem方法，并构造函数getItem通过参数ProcessPCB和String查找数组元素，定义getNumberOfItems取数组大小，定义getItemsPriorities方法取所有数组元素的toString

方法用于界面显示，定义iterator方法取得数组的迭代器；

MemoryItem类中，定义Memory的内存起始位置和所需内存大小、、、、、、

（5），MemoryRecords用同样的设计思想封装以MemoryItem为数组元素的各属性和方法；

（6）SingleCPUScheduling类继承JFrame类，实现界面化显示；与上面相对应，实例化ProcessRecords（3次）和MemoryRecords（1次）作为私有变量，分别作为后备队列、就绪队列、挂起队列和内存可分分区表；在界面设计中，设计后备队列、挂起队列（附带解挂umount按钮）、就绪队列（附带挂起suspend按钮）可分分区表列表显示框，设置PCB添加框，附带添加至后备队列（addToBackup）、添加至就绪队列（addToReady）按钮，以及CPU当前执行状态显示框、系统日志显示框，和开始调度（systemStart）按钮，优先级和时间片单选按钮，以及时间片显示标签和文本编辑框； （7）界面设计详解；后备队列显示框用于显示已添加至后备队列的ProcessRecords属性信息，其中主存起始位置默认为-1，表示未分配；挂起队列显示框用于显示从就绪队列挂起的PCB，其中属性“主存起始位置”（MemoryBase）将由非负数变为-1，表示挂起后收回内存；就绪队列显示框中显示就绪队列属性，其中“主存起始位置”均为非负，表示一分配内存；PCB信息添加框分列PCB6个属性显示标签和可编辑文本框，和添加按钮，用于添加PCB；系统日志显示框附属时间片显示标签和可编辑文本编辑框，可由用户决定时间片大小；

对于实验一，界面如下：

以上由SingleCPUScheduling001.java（另需ProcessPCB.java和PCBRdecords.java） （8）附属功能添加完善；最重要的是为程序添加线程，使程序能以停顿一段时间的频率自动运行；后备队列、挂起队列添加total显示标签和不可编辑文本显示框，用于显示各自数组中元素数目，挂起队列附属删除（remove）按钮，可删除挂起队列中的元素；后备、挂起、就绪队列均添加监听器，用于响应用户单击操作，可以在PCB信息添加框显示用户单击的那一条PCB的信息；PCB信息添加框附属reset按钮，用于一键清空信息框中信息，方便输入；系统日志面板附属系统暂停（systemPause）和系统重置（systemReset）按钮，分别用于暂停运行（方便用户观察当前运行结果）和重置系统（方便用户重复使用程序，免去关闭后重启本程序的麻烦）；最终界面如图：

实验结果报告级分析

1， 2，

程序完成了实验所有的基本要求；

本程序还存在一些技术上的问题，使得程序不能尽善尽美；如，PCB信息添加框没有“随机置入就绪队列”功能，添加PCB信息仍显得繁琐；就绪队列的挂起功能在程序自动运行时，存在反应异常（反应延迟或直接无反映）；可分分区表只显示了当前可分的内存，没有显示已分的PCB及其对应内存使用情况，且没有利用图形和丰富的颜色来更好的展示；时间片设计还需要改进，使用效率不高；系统重置功能存在响应延迟的问题；另外，界面不够美观；还需要不断改进； 实验感想

通过这次实验，我对操作系统的进程调度和内存分配管理有了更加深入的了解，对操作系统内部的工作原理有了进一步的认识；

通过编程，也巩固了我的程序设计和代码编写的能力，实验过程中遇到的各种问题以及解决问题的过程与方法，都是我获益匪浅；

同时，程序的不完善，也将促使我在课程之后，继续学习、理解课程内容，并尽一切努力不断完善程序，做到尽善尽美；

程序代码

完整版（初学java，菜鸟级别，当然是将所学的全部照办照抄，实为臃肿，可为初学者引以为戒，注意代码质量！）

这里谨贴出十分臃肿的代码，仅供初学者交流经验，重在开发的思想，了解开发的流程，而01版（精简版）代码在后面； ProcessPCB.java

package src;

public class ProcessPCB {

// backupBAK 后备 ready 就绪 suspend 挂起 memory内存 private String PID; private int RequiredTime; // private String Priority; private int Priority; private String Status;

private int MwmoryBase = 0000; private int MemoryLimit;

// private String PCBPointer;

public ProcessPCB(String initpID, int initRTime, int initpriority, String status, int initBase, int initLimit) {

this.PID = initpID;

this.RequiredTime = initRTime; this.Priority = initpriority; this.Status = status; this.MwmoryBase = initBase; this.MemoryLimit = initLimit;

}

public String getPID() { if(this.PID == null)

return \ else

return this.PID;

}

public void setPID(String pid) { if(pid == null)

this.PID = \ else

this.PID = pid;

}

public int getRequiredTime() { return this.RequiredTime; }

public void setRequiredTime(int time) { this.RequiredTime = time; }

public int getPriority() { return this.Priority; }

public void setPriority(int priority) { this.Priority = priority; }

public String getStatus() { }

public void setStatues(String statues) { }

public int getMemoryBase() { }

public void setMemoryBase(int base) { }

public int getMemoryLimit() { }

public void setMemoryLimit(int limit) { }

public boolean equals(ProcessPCB pcb) { }

public String toString() {

return this.getPID() + \ + this.getRequiredTime() + \ + this.getPriority() + \ + this.getStatus() + \ + this.getMemoryBase() + \ + this.getMemoryLimit()

if(pcb.getPID() == this.getPID()) { }

else return false;

return true;

this.MemoryLimit = limit; return this.MemoryLimit; this.MwmoryBase = base; return this.MwmoryBase; if(statues == null)

this.Status = \; if(this.Status == null)

return \;

else

return this.Status;

else

this.Status = statues;

+ \; }

public void run() { } }

this.RequiredTime = this.RequiredTime-1; this.Priority = this.Priority-1;

MemoryItem.java

package src;

public class MemoryItem { private int memoryBase=0; private int memoryLimit=0; private int availableStatus=0;

public MemoryItem(int initMemoryBase, int initMemoryLimit) { }

public int getMemoryBase() { }

public void setMemoryBase(int base) { }

public int getMemoryLimit() { }

public void setMemoryLimit(int limit) { }

public int getStatus() { }

public void setStatus(int status) { }

public String toString() {

return this.getMemoryBase() + \ + this.getMemoryLimit() + \; this.memoryBase = status; return this.availableStatus; this.memoryLimit = limit; return this.memoryLimit; this.memoryBase = base; return this.memoryBase;

this.memoryBase = initMemoryBase; this.memoryLimit = initMemoryLimit;

} }

PCBRecords.java package src;

import java.util.ArrayList; import java.util.Iterator;

public class PCBRecords implements Iterable {

private ArrayList PCBItems;

public ArrayList getPCBItems() { return this.PCBItems; }

public PCBRecords() { this.PCBItems = new ArrayList(); }

public void addItem(ProcessPCB PcbItem) { this.PCBItems.add(PcbItem); }

public void removeItem(ProcessPCB PCbItem) { this.PCBItems.remove(PCbItem); }

public ProcessPCB getItem(ProcessPCB processPCB) { for (ProcessPCB pCbItem : this.PCBItems) { if (pCbItem.equals(processPCB)) { return pCbItem; } } return null; }

public ProcessPCB getItem(String pid) { for (ProcessPCB pcBItem : this.PCBItems) { if (pcBItem.getPID().equals(pid)) { return pcBItem; } } return null; }

public int getNumberOfItems() { return this.PCBItems.size(); }

public String[] getItemsProperties() { String itemsProperties[] = new String[getNumberOfItems()]; int i = 0;

for(Iterator iterator1 = PCBItems.iterator(); iterator1.hasNext();)

{

ProcessPCB stu_Item = (ProcessPCB)iterator1.next(); itemsProperties[i++] = stu_Item.toString(); }

return itemsProperties; }

public Iterator iterator() { return this.PCBItems.iterator(); } }

MemoryRecords.java package src;

import java.util.ArrayList; import java.util.Iterator;

public class MemoryRecords implements Iterable { private ArrayList memoryItems;

public Iterator iterator() { // TODO Auto-generated method stub return this.memoryItems.iterator(); }

public ArrayList getMemoryItems() { return this.memoryItems; }

public MemoryRecords() {

this.memoryItems = new ArrayList(); }

public void addItem(MemoryItem newMemoryItem) { this.memoryItems.add(newMemoryItem); }

public void removeItem(MemoryItem momoryItem) { this.memoryItems.remove(momoryItem); }

public MemoryItem getMomoryItem(MemoryItem item) { for(MemoryItem mItem : this.memoryItems) { if(mItem.equals(item)) { return mItem; } }

return null; }

public MemoryItem getMemoryItem(int base) { for(MemoryItem mItem : this.memoryItems) { if(mItem.getMemoryBase() == base) { return mItem; } }

return null;

}

public int getNumberOfItems() { return this.memoryItems.size(); }

public String[] getItemsProperties() {

String itemsProperties[] = new String[getNumberOfItems()]; int i=0;

for(Iterator iterator1 = this.memoryItems.iterator(); iterator1.hasNext(); ) { MemoryItem mmItem = (MemoryItem) iterator1.next(); itemsProperties[i++] = mmItem.toString();//???? }

//System.out.println(itemsProperties + \ if(itemsProperties == null) { itemsProperties[0] = \ \ }

return itemsProperties; } }

SingleCPUSchedulingGUI001.Java

import java.util.*; import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.event.*;

import src.SingleCPUSchedulingGUI001.AddToBAKListener; import src.SingleCPUSchedulingGUI001.AddToReadyListener; import src.SingleCPUSchedulingGUI001.RemoveListener; import src.SingleCPUSchedulingGUI001.ResetListener;

import src.SingleCPUSchedulingGUI001.ResetSystemListener; import src.SingleCPUSchedulingGUI001.StartSystemListener; import src.SingleCPUSchedulingGUI001.SuspendListener; import src.SingleCPUSchedulingGUI001.SystemPauseListener; import src.SingleCPUSchedulingGUI001.UmountListener; import src.SingleCPUSchedulingGUI001.priotiryListener; import src.SingleCPUSchedulingGUI001.timeslicListener;

import java.io.*; import java.text.*;

public class SingleCPUSchedulingGUI001 extends JFrame {

private int systemStatues; //注意static 属性

/*define 0--system prepare status--system reset and re-prepare 1--system start 2--system pause 3--system stop*/

/* Standar error stream */

static private PrintWriter stdErr = new PrintWriter(System.err, true);

static private int WIDTH = 600, HEIGHT = 700; // the size of the Frame 主面板

/* 各列表对应的面板规格*/

/* 对应各名词释义 backupBAK 后备 ready 就绪 suspend 挂起 memory内存 */ static private int BackupBAK_CELL_SIZE = 250, BackupBAK_LIST_ROWS = 10; //后备队列 static private int Suspend_CELL_SIZE = 250, Suspend_LIST_ROWS = 10; //挂起队列

static private int Ready_CELL_SIZE = 200, Ready_LIST_ROWS = 6; //就绪队列 static private int CPU_ROWS = 10, CPU_COLS = 22; //CPU面板 static private int STATUS_ROWS = 8, STATUS_COLS = 30; //系统状态面板 private int timeslice = 1; //设置时间片大小

private int systemStatus=0; //设置系统状态 0——系统预备状态，等待开始，1——系统运行状态，2——系统暂停状态

static private int TOTAL__TEXTFIELD_SIZE = 10; // Size total text field 记录各队列元素个数

private JList backupList, suspendList, readyList; //各队列相对应的数组列表 // 进程添加框中的\添加至后备队列\，\添加至就绪队列\，\重置\ private JButton addToBAKButton, addToReadyButton, resetButton; //就绪队列框中的\挂起\，挂起队列框中的\解挂\，\删除\ private JButton suspendButton, umountButton, removeButton; //Status面板中的\启动系统\，\重置系统\

private JButton startButton, pauseButton, resetSyatemButton; //优先级和时间片单选钮及时间片显示框 private JRadioButton priorityJRB, timesliceJRB; private JLabel timesliceSizeLabel; private JTextField timesliceJtf;

//后备面板、进程添加面板、挂起面板、内存面板

private JPanel backupBAKPanel, PCBItemPanel, suspendedPanel; //后备队列、挂起队列元素总数标签 private JLabel backupTotalLabel, suspendTotalLabel;

//进程信息标签 进程编号PID,所需运行时间requiredTime,优先级priority,当前状态statues,内存中的基址base,所需内存大小limit

private JLabel PIDLabel, requiredTimeLabel, priorityLabel, statuesLabel; //后备队列、挂起队列元素总数文本框（不可编辑） private JTextField backupTotalTextField, suspendTotalTextField;

//进程信息文本框 PID(可编辑),requiredTime(可编辑),priority(可编辑),status(不可编辑),base(不可编辑),limit(可编辑)

private JTextField PIDTextField, requiredTimeTextField, priorityTextField, statusTextField;

//CPU状态显示文本域(不可编辑)，status信息文本域(用于现实程序每一步的操作和影响，不可编辑)

private JTextArea CPUTextArea, statuesTextArea;

//后备队列PCB数组,就绪、挂起，——内存（可分分区表） PCBRecords backupPCB, readyPCB, suspendedPCB;

public static void main(String[] args) throws IOException { // TODO Auto-generated method stub new SingleCPUSchedulingGUI001().initFrame(); }

public void initFrame() { backupList = new JList(); backupList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); backupList.setVisibleRowCount(BackupBAK_LIST_ROWS); backupList.setFixedCellWidth(BackupBAK_CELL_SIZE); suspendList = new JList(); suspendList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); suspendList.setVisibleRowCount(Suspend_LIST_ROWS); suspendList.setFixedCellWidth(Suspend_CELL_SIZE); readyList = new JList(); readyList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); readyList.setVisibleRowCount(Ready_LIST_ROWS); readyList.setFixedCellWidth(Ready_CELL_SIZE); suspendButton = new JButton(\

addToBAKButton = new JButton(\ addToReadyButton = new JButton(\ resetButton = new JButton(\ umountButton = new JButton(\ removeButton = new JButton(\ startButton = new JButton(\ pauseButton = new JButton(\ resetSyatemButton = new JButton(\ priorityJRB = new JRadioButton(\ timesliceJRB = new JRadioButton(\ backupTotalLabel = new JLabel(\ backupTotalTextField = new JTextField(\ backupTotalTextField.setEditable(false); suspendTotalLabel = new JLabel(\ suspendTotalTextField = new JTextField(\ suspendTotalTextField.setEditable(false); timesliceSizeLabel = new JLabel(\ timesliceJtf = new JTextField(\ timesliceJtf.setEditable(true); CPUTextArea = new JTextArea(CPU_ROWS, CPU_COLS); CPUTextArea.setEditable(false); statuesTextArea = new JTextArea(STATUS_ROWS, STATUS_COLS); statuesTextArea.setEditable(false);

/* north panel*/

// JPanel northPanel = new JPanel(new BorderLayout()); JPanel northPanel = new JPanel(new GridLayout(1, 3)); // JPanel north = new JPanel(new BorderLayout());

// ProcessPCB item information Panel PCBItemPanel = new JPanel(new BorderLayout()); PCBItemPanel.setBorder( BorderFactory.createTitledBorder(\ JPanel PCBItemButtonJPanel = new JPanel(new GridLayout(3, 1)); PCBItemButtonJPanel.add(addToBAKButton); PCBItemButtonJPanel.add(addToReadyButton); PCBItemButtonJPanel.add(resetButton); PCBItemPanel.add(this.initPCBItemPanel(), BorderLayout.CENTER); PCBItemPanel.add(PCBItemButtonJPanel, BorderLayout.SOUTH);

//backupBAKList Panel backupBAKPanel = new JPanel(new BorderLayout()); backupBAKPanel.setBorder(BorderFactory.createTitledBorder(\

JPanel backupTotalPAnel = new JPanel(); backupTotalPAnel.add(backupTotalLabel); backupTotalPAnel.add(backupTotalTextField); backupBAKPanel.add ( new JScrollPane(backupList, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED), BorderLayout.CENTER);

backupBAKPanel.add(backupTotalPAnel, BorderLayout.SOUTH);

// north.add(backupBAKPanel, BorderLayout.WEST); // north.add(PCBItemPanel, BorderLayout.CENTER);

// SuspendList Panel

suspendedPanel = new JPanel(new BorderLayout());

suspendedPanel.setBorder(BorderFactory.createTitledBorder(\

JPanel suspendedTotalPAnel = new JPanel(); suspendedTotalPAnel.add(suspendTotalLabel); suspendedTotalPAnel.add(suspendTotalTextField);

JPanel suspendComponentPanel = new JPanel(new GridLayout(1, 2)); suspendComponentPanel.add(umountButton); suspendComponentPanel.add(removeButton);

suspendedPanel.add (suspendedTotalPAnel, BorderLayout.NORTH); suspendedPanel.add ( new JScrollPane(suspendList, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED), BorderLayout.CENTER);

suspendedPanel.add(suspendComponentPanel, BorderLayout.SOUTH);

// northPanel.add(north, BorderLayout.CENTER);

// northPanel.add(suspendedPanel, BorderLayout.EAST); northPanel.add(backupBAKPanel); northPanel.add(PCBItemPanel); northPanel.add(suspendedPanel); /* center Panel*/

JPanel centrelPanel = new JPanel(new BorderLayout()); // JPanel centrelPanel = new JPanel(new GridLayout(1, 3));

// readyList panel

JPanel readyListPanel = new JPanel(new BorderLayout());

readyListPanel.setBorder(BorderFactory.createTitledBorder(\ readyListPanel.add ( new JScrollPane(readyList, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));//, BorderLayout.CENTER

readyListPanel.add (suspendButton, BorderLayout.SOUTH); // CPU panel

JPanel CPUPanel = new JPanel();

CPUPanel.setBorder(BorderFactory.createTitledBorder(\ CPUPanel.add (new JScrollPane(CPUTextArea, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));

centrelPanel.add(readyListPanel, BorderLayout.WEST); centrelPanel.add(CPUPanel, BorderLayout.CENTER);

/*statues panel*/

JPanel southPanel = new JPanel(new BorderLayout());

JPanel statuesPanel = new JPanel();

statuesPanel.setBorder(BorderFactory.createTitledBorder(\ statuesPanel.add (new JScrollPane(statuesTextArea,

JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)); //, BorderLayout.CENTER //statuesPanel.setSize(400, 100);

//statuesPanel.setPreferredSize(new Dimension(400, 10));

JPanel systemContralButtonPanel = new JPanel(new GridLayout(6, 1));

systemContralButtonPanel.setBorder(BorderFactory.createTitledBorder(\ ButtonGroup group = new ButtonGroup(); group.add(priorityJRB); group.add(timesliceJRB);

JPanel porityPanel = new JPanel(new GridLayout(1, 2)); porityPanel.add(timesliceSizeLabel); porityPanel.add(timesliceJtf);

systemContralButtonPanel.add(priorityJRB); systemContralButtonPanel.add(timesliceJRB); systemContralButtonPanel.add(porityPanel); systemContralButtonPanel.add(startButton); systemContralButtonPanel.add(pauseButton);

systemContralButtonPanel.add(resetSyatemButton);

southPanel.add(statuesPanel, BorderLayout.CENTER);

southPanel.add(systemContralButtonPanel, BorderLayout.EAST); // arrange panels in window setLayout(new BorderLayout()); add(northPanel, BorderLayout.NORTH); add(centrelPanel, BorderLayout.CENTER); add(southPanel, BorderLayout.SOUTH); //statuesPanel // start listening for list and buttons events addToBAKButton.addActionListener(new AddToBAKListener()); addToReadyButton.addActionListener(new AddToReadyListener()); resetButton.addActionListener(new ResetListener()); suspendButton.addActionListener(new SuspendListener()); umountButton.addActionListener(new UmountListener()); removeButton.addActionListener(new RemoveListener()); startButton.addActionListener(new StartSystemListener()); pauseButton.addActionListener(new SystemPauseListener()); resetSyatemButton.addActionListener(new ResetSystemListener()); priorityJRB.addActionListener(new priotiryListener()); timesliceJRB.addActionListener(new timeslicListener()); backupPCB = new PCBRecords(); readyPCB = new PCBRecords(); suspendedPCB = new PCBRecords(); backupList.setListData(backupPCB.getItemsProperties()); readyList.setListData(readyPCB.getItemsProperties()); suspendList.setListData(suspendedPCB.getItemsProperties()); this.setTitle(\ this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setSize(WIDTH, HEIGHT); this.setResizable(true); this.setVisible(true); this.setLocation(200, 10); }

public JPanel initPCBItemPanel() { JPanel iniPCBItemJPanel = new JPanel(new BorderLayout()); JPanel iniNamePanel = new JPanel(new GridLayout(4, 1)); JPanel iniValuePanel = new JPanel(new GridLayout(4, 1)); PIDLabel = new JLabel(\ requiredTimeLabel = new JLabel(\ priorityLabel = new JLabel(\ statuesLabel = new JLabel(\ iniNamePanel.add(PIDLabel); iniNamePanel.add(requiredTimeLabel); iniNamePanel.add(priorityLabel); iniNamePanel.add(statuesLabel); PIDTextField = new JTextField(\ PIDTextField.setEditable(true); requiredTimeTextField = new JTextField(\ requiredTimeTextField.setEditable(true); priorityTextField = new JTextField(\ priorityTextField.setEditable(true); statusTextField = new JTextField(\ statusTextField.setEditable(false); iniValuePanel.add(PIDTextField); iniValuePanel.add(requiredTimeTextField); iniValuePanel.add(priorityTextField); iniValuePanel.add(statusTextField); iniPCBItemJPanel.add(iniNamePanel, BorderLayout.WEST); iniPCBItemJPanel.add(iniValuePanel, BorderLayout.CENTER); return iniPCBItemJPanel; }

public int readInteger(String s) { int num = -1; try { num = Integer.parseInt(s); } catch(NumberFormatException numberformatexception) { statuesTextArea.append(\ num = -999; } return num; }

public void addToBackupList(String newID, int s1, int s2, String s) { ProcessPCB item = backupPCB.getItem(newID); if(item != null) { statuesTextArea.append(\ + \ while(item != null) { newID = s + newID; item = backupPCB.getItem(newID); } }

ProcessPCB newPCB = new ProcessPCB(newID, s1, s2, \ backupPCB.addItem(newPCB);

backupList.setListData(backupPCB.getItemsProperties());

backupTotalTextField.setText(Integer.toString(backupPCB.getNumberOfItems()));

}

public void addToReadyList(String nowID, int s1, int s2, String s) { ProcessPCB item = readyPCB.getItem(nowID); if(item != null) { statuesTextArea.append(\ + \ while(item != null) { nowID = s + nowID; item = backupPCB.getItem(nowID); } }

ProcessPCB newPCB = new ProcessPCB(nowID, s1, s2, \ readyPCB.addItem(newPCB); sortReadyPCB();

readyList.setListData(readyPCB.getItemsProperties()); }

class AddToBAKListener implements ActionListener { public void actionPerformed(ActionEvent event) { String newID = PIDTextField.getText(); String newTime = requiredTimeTextField.getText(); String newPriority = priorityTextField.getText(); int s1 = 0, s2 = 0, tag1=-1, tag2=-1; if(newTime != null) { s1 = readInteger(newTime); if(s1 > 0.0) tag1 = 1;

else statuesTextArea.append(\ } if(newPriority != null) { s2 = readInteger(newPriority); if(s1 != -999) tag2 = 1;

else statuesTextArea.append(\ } if(tag1 ==1 && tag2 == 1 ) { if(newID == null) { statuesTextArea.append(\ } else { addToBackupList(newID, s1, s2, \

statuesTextArea.append(\ reset(); } } } }

class AddToReadyListener implements ActionListener { public void actionPerformed(ActionEvent event) { String nowID = PIDTextField.getText(); String time = requiredTimeTextField.getText(); String priority = priorityTextField.getText(); int s1 = 0, s2 = 0; int tag1 = -1, tag2 = -1; if(time != null)

{ s1 = readInteger(time); if(s1 > 0.0) tag1=1;

else statuesTextArea.append(\ } if(priority != null) { s2 = readInteger(priority); if(s2 != -999) tag2=1;

else statuesTextArea.append(\ }

if(tag1 ==1 && tag2 == 1) { if(nowID == null) { statuesTextArea.append(\ } else { if(readyPCB.getNumberOfItems() < 6) { addToReadyList(nowID, s1, s2, \ statuesTextArea.append(\student record item has been added to ReadyList!\\n\ } else { statuesTextArea.append(\added to BackupList!\\n\ addToBackupList(nowID, s1, s2, \ statuesTextArea.append(\student record item has been added to BackupList!\\n\ } reset(); } } } }

public void reset() { PIDTextField.setText(\ requiredTimeTextField.setText(\ priorityTextField.setText(\ statusTextField.setText(\ } /**

* This inner class processes resetButton events. */

class ResetListener implements ActionListener { public void actionPerformed(ActionEvent event) { reset(); } } /**

* This inner class processes suspendButton events. */

//注：在挂起时，不会触发进程调度，而是在点击\时才会出发进程调度 class SuspendListener implements ActionListener { /** * Removes an order item from the current order. * * @param event the event object.

*/ public void actionPerformed(ActionEvent event) { String selectedReadyItem = null; String pid = \ if(readyPCB.getNumberOfItems() == 0) { statuesTextArea.append(\ } else {

selectedReadyItem = (String) readyList.getSelectedValue(); if(selectedReadyItem == null) {

statuesTextArea.append(\ } else {

StringTokenizer stringtokenizer = new StringTokenizer(selectedReadyItem, \ pid = stringtokenizer.nextToken(); ProcessPCB selectedItem = readyPCB.getItem(pid); if(selectedItem == null) { statuesTextArea.append(\student recorditem of Num \+ pid + \is founded!\\n\

} else { ProcessPCB boolTtem = suspendedPCB.getItem(pid); if(boolTtem != null) { statuesTextArea.append(\PCB \+ pid + \has existed in Suspend List!\\n\ + \ while(boolTtem != null) { pid = \ boolTtem = suspendedPCB.getItem(pid); } } ProcessPCB newPcb = new ProcessPCB(pid, selectedItem.getRequiredTime(), selectedItem.getPriority(),\ suspendedPCB.addItem(newPcb); readyPCB.removeItem(selectedItem); sortReadyPCB(); //注意考虑一下 suspendList.setListData(suspendedPCB.getItemsProperties()); readyList.setListData(readyPCB.getItemsProperties());

statuesTextArea.append(\

suspendTotalTextField.setText(Integer.toString(suspendedPCB.getNumberOfItems())); }

} } } }

public void sortReadyPCB() { PCBRecords currentReadyPCB = new PCBRecords(); int num = readyPCB.getNumberOfItems(); if(num > 0) { for(int i=num; i>=1; i--) { Iterator readyIterator = readyPCB.iterator(); ProcessPCB currentItem = (ProcessPCB) readyIterator.next(); for( ; readyIterator.hasNext(); ) { ProcessPCB nowItem = (ProcessPCB) readyIterator.next(); if(currentItem.getPriority() < nowItem.getPriority()) { currentItem = null;

currentItem = nowItem; } } currentReadyPCB.addItem(currentItem); readyPCB.removeItem(currentItem); } readyPCB = null; readyPCB = currentReadyPCB; } } /**

* This inner class processes umountButton events. */

class UmountListener implements ActionListener { /** * Removes an order item from the current order. * * @param event the event object. */ public void actionPerformed(ActionEvent event) { String selectedSuspendedItem = null; String id = \ if(suspendedPCB.getNumberOfItems() == 0) { statuesTextArea.append(\ } else {

selectedSuspendedItem = (String) suspendList.getSelectedValue(); if(selectedSuspendedItem == null) {

statuesTextArea.append(\ } else {

StringTokenizer stringtokenizer = new StringTokenizer(selectedSuspendedItem, \ id = stringtokenizer.nextToken(); ProcessPCB selectedItem = suspendedPCB.getItem(id); if(selectedItem == null) { statuesTextArea.append(\student recorditem of Num \+ id + \is founded!\\n\

} else { if(readyPCB.getNumberOfItems() < 6) { ProcessPCB selectedToItem = readyPCB.getItem(id); if(selectedToItem != null) { statuesTextArea.append(\The PID will be modify!\\n\ while(selectedToItem != null) { id = id+\ selectedToItem = readyPCB.getItem(id); } } ProcessPCB newToItemPCB = new ProcessPCB(id, selectedItem.getRequiredTime(), selectedItem.getPriority(), \ readyPCB.addItem(newToItemPCB); suspendedPCB.removeItem(selectedItem); suspendList.setListData(suspendedPCB.getItemsProperties());

suspendTotalTextField.setText(Integer.toString(suspendedPCB.getNumberOfItems())); sortReadyPCB(); //注意考虑 readyList.setListData(readyPCB.getItemsProperties()); statuesTextArea.append(\product has been Umounted to Ready List!\\n\

} else { statuesTextArea.append(\The new ProcessPCB will be Umounted to BackupList!\\n\ ProcessPCB selectedToItem = backupPCB.getItem(id); if(selectedToItem != null) { statuesTextArea.append(\The PID will be modify!\\n\ while(selectedToItem != null) { id = id+\ selectedToItem = backupPCB.getItem(id); } } ProcessPCB newToItemPCB = new ProcessPCB(id, selectedItem.getRequiredTime(), selectedItem.getPriority(), \ backupPCB.addItem(newToItemPCB); suspendedPCB.removeItem(selectedItem); suspendList.setListData(suspendedPCB.getItemsProperties()); backupList.setListData(backupPCB.getItemsProperties());

suspendTotalTextField.setText(Integer.toString(suspendedPCB.getNumberOfItems())); statuesTextArea.append(\product has been Umounted to Backup List!\\n\

}

} } } } } /**

* This inner class processes removeButton events. */

class RemoveListener implements ActionListener { public void actionPerformed(ActionEvent event) { String selectedRemovsItem = null; String id = \ if(suspendedPCB.getNumberOfItems() == 0) { statuesTextArea.append(\ } else {

selectedRemovsItem = (String) suspendList.getSelectedValue(); if(selectedRemovsItem == null) {

statuesTextArea.append(\ } else {

StringTokenizer stringtokenizer = new StringTokenizer(selectedRemovsItem, \ id = stringtokenizer.nextToken(); ProcessPCB suspendedItem = suspendedPCB.getItem(id); if(suspendedItem == null) { statuesTextArea.append(\student recorditem of Num \+ id + \is founded!\\n\

} else { suspendedPCB.removeItem(suspendedItem); suspendList.setListData(suspendedPCB.getItemsProperties()); statuesTextArea.append(\

suspendTotalTextField.setText(Integer.toString(suspendedPCB.getNumberOfItems())); } } } } }

public void PCBSchudling() { while(readyPCB.getNumberOfItems() < 6) { if(backupPCB.getNumberOfItems() > 0) { Iterator bwackupPCBIterator = backupPCB.iterator(); ProcessPCB newItem = (ProcessPCB) bwackupPCBIterator.next(); readyPCB.addItem(newItem); backupPCB.removeItem(newItem); //注意考虑要不要排序 sortReadyPCB(); readyList.setListData(readyPCB.getItemsProperties()); backupList.setListData(backupPCB.getItemsProperties()); backupTotalTextField.setText(Integer.toString(backupPCB.getNumberOfItems())); } else break; } }

public void run() { PCBSchudling(); if(readyPCB.getNumberOfItems() > 0) { Iterator readyIterator = readyPCB.iterator(); ProcessPCB runningItem = (ProcessPCB) readyIterator.next(); if(runningItem.getRequiredTime()>0) { runningItem.run(); CPUTextArea.append(\ } if(runningItem.getRequiredTime() <= 0) { statuesTextArea.append(\the memory!\\n\ readyPCB.removeItem(runningItem); runningItem = null; //注意 PCBSchudling(); } sortReadyPCB(); readyList.setListData(readyPCB.getItemsProperties()); } else { this.systemStatues = 0; System.exit(0); } }

boolean getSystemStatues() { if(this.systemStatues == 1) return true;

else return false; }

class StartSystemListener implements ActionListener { public void actionPerformed(ActionEvent event) { systemStatues = 1; run(); } }

class SystemPauseListener implements ActionListener { public void actionPerformed(ActionEvent event) { systemStatues = 2; } }

class StopSystemListener implements ActionListener { public void actionPerformed(ActionEvent event) { systemStatues = 3; } }

class ResetSystemListener implements ActionListener { public void actionPerformed(ActionEvent event) { systemStatues = 0; } }

class priotiryListener implements ActionListener { public void actionPerformed(ActionEvent event) { timeslice = 1; } }

class timeslicListener implements ActionListener { public void actionPerformed(ActionEvent event) { timeslice = getTimesliceText(); if(timeslice <= 0) { statuesTextArea.append(\ timesliceJtf.setText(\ timeslice = 1; } } }

public int getTimesliceText() { int n; try { n = Integer.parseInt(timesliceJtf.getText()); } catch(NumberFormatException numberformatexception) { statuesTextArea.append(\ n = -999; } return n; } }

01版（精简版） MemoryItem.java package src;

public class MemoryItem { private int memoryBase=0; private int memoryLimit=0; private int availableStatus=0;

public MemoryItem(int initMemoryBase, int initMemoryLimit) { this.memoryBase = initMemoryBase; this.memoryLimit = initMemoryLimit; }

public int getMemoryBase() { return this.memoryBase; }

public int getMemoryLimit() { return this.memoryLimit; }

public int getStatus() { return this.availableStatus; }

public String toString() {

return this.getMemoryBase() + \ } }

ProcessPCB.java package src;

public class ProcessPCB {

// backupBAK 后备 ready 就绪 suspend 挂起 memory内存 private String PID;

private int RequiredTime; private int Priority; private String Status;

private int MwmoryBase = 0000; private int MemoryLimit; // private String PCBPointer;

public ProcessPCB(String initpID, int initRTime, int initpriority, String status, int initBase, int initLimit) { this.PID = initpID; this.RequiredTime = initRTime; this.Priority = initpriority; this.Status = status; this.MwmoryBase = initBase; this.MemoryLimit = initLimit; }

public String getPID() { if(this.PID == null) return \ else return this.PID; }

public int getRequiredTime() { return this.RequiredTime; }

public int getPriority() { return this.Priority; }

public String getStatus() { if(this.Status == null) return \ else return this.Status; }

public int getMemoryBase() { return this.MwmoryBase; }

public int getMemoryLimit() { return this.MemoryLimit; }

public boolean equals(ProcessPCB pcb) { if(pcb.getPID() == this.getPID()) { return true; } else return false; }

public String toString() { return this.getPID() + \ + this.getStatus() + \ }

public void run() { this.RequiredTime = this.RequiredTime-1; this.Priority = this.Priority-1; } }

PCBRecords.java package src;

import java.util.ArrayList; import java.util.Iterator;

public class PCBRecords implements Iterable {

private ArrayList PCBItems;

public ArrayList getPCBItems() { return this.PCBItems; }

public PCBRecords() { this.PCBItems = new ArrayList(); }

public void addItem(ProcessPCB PcbItem) { this.PCBItems.add(PcbItem); }

public void removeItem(ProcessPCB PCbItem) { this.PCBItems.remove(PCbItem); }

public ProcessPCB getItem(ProcessPCB processPCB) { for (ProcessPCB pCbItem : this.PCBItems) { if (pCbItem.equals(processPCB)) { return pCbItem; } } return null; }

public ProcessPCB getItem(String pid) { for (ProcessPCB pcBItem : this.PCBItems) { if (pcBItem.getPID().equals(pid)) { return pcBItem; } } return null; }

public int getNumberOfItems() { return this.PCBItems.size(); }

public String[] getItemsProperties() { String itemsProperties[] = new String[getNumberOfItems()]; int i = 0;

for(Iterator iterator1 = PCBItems.iterator(); iterator1.hasNext();) {

ProcessPCB stu_Item = (ProcessPCB)iterator1.next(); itemsProperties[i++] = stu_Item.toString(); }

return itemsProperties; }

public Iterator iterator() { return this.PCBItems.iterator(); } }

MemoryRecords.java package src;

import java.util.ArrayList; import java.util.Iterator;

public class MemoryRecords implements Iterable { private ArrayList memoryItems;

public Iterator iterator() { // TODO Auto-generated method stub return this.memoryItems.iterator(); }

public ArrayList getMemoryItems() { return this.memoryItems; }

public MemoryRecords() {

this.memoryItems = new ArrayList(); }

public void addItem(MemoryItem newMemoryItem) { this.memoryItems.add(newMemoryItem); }

public void removeItem(MemoryItem momoryItem) { this.memoryItems.remove(momoryItem); }

public MemoryItem getMomoryItem(MemoryItem item) { for(MemoryItem mItem : this.memoryItems) { if(mItem.equals(item)) { return mItem; } }

return null; }

public MemoryItem getMemoryItem(int base) { for(MemoryItem mItem : this.memoryItems) { if(mItem.getMemoryBase() == base) { return mItem; } }

return null; }

public int getNumberOfItems() { return this.memoryItems.size(); }

public String[] getItemsProperties() {

String itemsProperties[] = new String[getNumberOfItems()]; int i=0;

for(Iterator iterator1 = this.memoryItems.iterator(); iterator1.hasNext(); ) { MemoryItem mmItem = (MemoryItem) iterator1.next(); itemsProperties[i++] = mmItem.toString(); }

if(itemsProperties == null) { itemsProperties[0] = \ \ }

return itemsProperties; } }

SingleCPUSchedulingGUI03.java package src;

import java.util.*; import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.event.*;

import src.SingleCPUSchedulingGUI03.AddToBAKListener; import src.SingleCPUSchedulingGUI03.AddToReadyListener;

import src.SingleCPUSchedulingGUI03.DisplayBackupProcessListener; import src.SingleCPUSchedulingGUI03.DisplaySuspendedProcessListener; import src.SingleCPUSchedulingGUI03.DisplayreadyProcessListener; import src.SingleCPUSchedulingGUI03.RemoveListener; import src.SingleCPUSchedulingGUI03.ResetListener;

import src.SingleCPUSchedulingGUI03.ResetSystemListener; import src.SingleCPUSchedulingGUI03.StartSystemListener; import src.SingleCPUSchedulingGUI03.SuspendListener; import src.SingleCPUSchedulingGUI03.UmountListener; //import src.myframe.MyWindowMonitor;

import java.io.*; import java.text.*;

public class SingleCPUSchedulingGUI03 extends JFrame { /* Standar error stream */

static private PrintWriter stdErr = new PrintWriter(System.err, true);

static private int WIDTH = 800, HEIGHT = 750; // the size of the Frame 主面板

/* 各列表对应的面板规格*/

/* 对应各名词释义 backupBAK 后备 ready 就绪 suspend 挂起 memory内存 */ static private int BackupBAK_CELL_SIZE = 250, BackupBAK_LIST_ROWS = 10; //后备队列 static private int Suspend_CELL_SIZE = 250, Suspend_LIST_ROWS = 10; //挂起队列 static private int Ready_CELL_SIZE = 200, Ready_LIST_ROWS = 6; //就绪队列 static private int Memory_CELL_SIZE = 200, Memory_LIST_ROWS = 10; //内存队列 static private int CPU_ROWS = 12, CPU_COLS = 22; //CPU面板 static private int STATUS_ROWS = 8, STATUS_COLS = 30; //系统状态面板 private int timeslice = 1; //设置时间片大小 private int systemStatus=0; //设置系统状态 0——系统预备状态，等待开始，1——系统运行状态，2——系统暂停状态

static private int TOTAL__TEXTFIELD_SIZE = 10; // Size total text field 记录各队列元素个数

private JList backupList, suspendList, readyList, memoryList; //各队列相对应的数组列表 // 进程添加框中的\添加至后备队列\，\添加至就绪队列\，\重置\ private JButton addToBAKButton, addToReadyButton, resetButton; //就绪队列框中的\挂起\，挂起队列框中的\解挂\，\删除\ private JButton suspendButton, umountButton, removeButton; //Status面板中的\启动系统\，\重置系统\

private JButton startButton, pauseButton, resetSyatemButton; //优先级和时间片单选钮及时间片显示框 private JRadioButton priorityJRB, timesliceJRB; private JLabel timesliceSizeLabel; private JTextField timesliceJtf;

//后备面板、进程添加面板、挂起面板、内存面板

private JPanel backupBAKPanel, PCBItemPanel, suspendedPanel, memoryPanel; //后备队列、挂起队列元素总数标签 private JLabel backupTotalLabel, suspendTotalLabel;

//进程信息标签 进程编号PID,所需运行时间requiredTime,优先级priority,当前状态statues,内存中的基址base,所需内存大小limit

private JLabel PIDLabel, requiredTimeLabel, priorityLabel, statuesLabel, baseLabel, limitLabel; //后备队列、挂起队列元素总数文本框（不可编辑） private JTextField backupTotalTextField, suspendTotalTextField;

//进程信息文本框 PID(可编辑),requiredTime(可编辑),priority(可编辑),status(不可编辑),base(不可编辑),limit(可编辑)

private JTextField PIDTextField, requiredTimeTextField, priorityTextField, statusTextField, baseTextField, limitTextField;

//CPU状态显示文本域(不可编辑)，status信息文本域(用于现实程序每一步的操作和影响，不可编辑)

private JTextArea CPUTextArea, statuesTextArea;

//后备队列PCB数组,就绪、挂起，——内存（可分分区表） PCBRecords backupPCB, readyPCB, suspendedPCB; private MemoryRecords memoryItems;

private boolean flag = false; //main函数

public static void main(String[] args) throws IOException { new SingleCPUSchedulingGUI03().initFrame(); }

//初始化Frame

public void initFrame() { backupList = new JList(); backupList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); backupList.setVisibleRowCount(BackupBAK_LIST_ROWS); backupList.setFixedCellWidth(BackupBAK_CELL_SIZE); suspendList = new JList(); suspendList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); suspendList.setVisibleRowCount(Suspend_LIST_ROWS); suspendList.setFixedCellWidth(Suspend_CELL_SIZE); readyList = new JList(); readyList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); readyList.setVisibleRowCount(Ready_LIST_ROWS); readyList.setFixedCellWidth(Ready_CELL_SIZE); memoryList = new JList(); memoryList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); memoryList.setVisibleRowCount(Memory_LIST_ROWS); memoryList.setFixedCellWidth(Memory_CELL_SIZE); suspendButton = new JButton(\ addToBAKButton = new JButton(\ addToReadyButton = new JButton(\ resetButton = new JButton(\ umountButton = new JButton(\ removeButton = new JButton(\ startButton = new JButton(\ pauseButton = new JButton(\

resetSyatemButton = new JButton(\ priorityJRB = new JRadioButton(\ timesliceJRB = new JRadioButton(\ backupTotalLabel = new JLabel(\ backupTotalTextField = new JTextField(\ backupTotalTextField.setEditable(false); suspendTotalLabel = new JLabel(\ suspendTotalTextField = new JTextField(\ suspendTotalTextField.setEditable(false); timesliceSizeLabel = new JLabel(\ timesliceJtf = new JTextField(\ timesliceJtf.setEditable(true); CPUTextArea = new JTextArea(CPU_ROWS, CPU_COLS); CPUTextArea.setEditable(false); statuesTextArea = new JTextArea(STATUS_ROWS, STATUS_COLS); statuesTextArea.setEditable(false);

/* north panel*/ JPanel northPanel = new JPanel(new GridLayout(1, 3)); // ProcessPCB item information Panel PCBItemPanel = new JPanel(new BorderLayout()); PCBItemPanel.setBorder( BorderFactory.createTitledBorder(\ JPanel PCBItemButtonJPanel = new JPanel(new GridLayout(3, 1)); PCBItemButtonJPanel.add(addToBAKButton); PCBItemButtonJPanel.add(addToReadyButton); PCBItemButtonJPanel.add(resetButton); PCBItemPanel.add(this.initPCBItemPanel(), BorderLayout.CENTER); PCBItemPanel.add(PCBItemButtonJPanel, BorderLayout.SOUTH);

//backupBAKList Panel backupBAKPanel = new JPanel(new BorderLayout()); backupBAKPanel.setBorder(BorderFactory.createTitledBorder(\

JPanel backupTotalPAnel = new JPanel(); backupTotalPAnel.add(backupTotalLabel); backupTotalPAnel.add(backupTotalTextField); backupBAKPanel.add ( new JScrollPane(backupList, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED), BorderLayout.CENTER); backupBAKPanel.add(backupTotalPAnel, BorderLayout.SOUTH);

// SuspendList Panel

suspendedPanel = new JPanel(new BorderLayout());

suspendedPanel.setBorder(BorderFactory.createTitledBorder(\

JPanel suspendedTotalPAnel = new JPanel(); suspendedTotalPAnel.add(suspendTotalLabel); suspendedTotalPAnel.add(suspendTotalTextField);

JPanel suspendComponentPanel = new JPanel(new GridLayout(1, 2)); suspendComponentPanel.add(umountButton); suspendComponentPanel.add(removeButton);

suspendedPanel.add (suspendedTotalPAnel, BorderLayout.NORTH); suspendedPanel.add ( new JScrollPane(suspendList, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED), BorderLayout.CENTER); suspendedPanel.add(suspendComponentPanel, BorderLayout.SOUTH);

northPanel.add(backupBAKPanel); northPanel.add(PCBItemPanel); northPanel.add(suspendedPanel); /* center Panel*/

JPanel centrelPanel = new JPanel(new GridLayout(1, 3));

// readyList panel

JPanel readyListPanel = new JPanel(new BorderLayout());

readyListPanel.setBorder(BorderFactory.createTitledBorder(\ readyListPanel.add ( new JScrollPane(readyList, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)); readyListPanel.add (suspendButton, BorderLayout.SOUTH); // CPU panel

JPanel CPUPanel = new JPanel();

CPUPanel.setBorder(BorderFactory.createTitledBorder(\ CPUPanel.add (new JScrollPane(CPUTextArea, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));

memoryPanel = new JPanel(new BorderLayout());

memoryPanel.setBorder(BorderFactory.createTitledBorder(\ memoryPanel.add ( new JScrollPane(memoryList, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));

centrelPanel.add(readyListPanel); centrelPanel.add(CPUPanel);

centrelPanel.add(memoryPanel); /*statues panel*/

JPanel southPanel = new JPanel(new BorderLayout());

JPanel statuesPanel = new JPanel();

statuesPanel.setBorder(BorderFactory.createTitledBorder(\ statuesPanel.add (new JScrollPane(statuesTextArea, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));

JPanel systemContralButtonPanel = new JPanel(new GridLayout(6, 1));

systemContralButtonPanel.setBorder(BorderFactory.createTitledBorder(\ ButtonGroup group = new ButtonGroup(); group.add(priorityJRB); group.add(timesliceJRB);

JPanel porityPanel = new JPanel(new GridLayout(1, 2)); porityPanel.add(timesliceSizeLabel); porityPanel.add(timesliceJtf);

systemContralButtonPanel.add(priorityJRB);

systemContralButtonPanel.add(timesliceJRB); systemContralButtonPanel.add(porityPanel); systemContralButtonPanel.add(startButton); systemContralButtonPanel.add(pauseButton);

systemContralButtonPanel.add(resetSyatemButton);

southPanel.add(statuesPanel, BorderLayout.CENTER);

southPanel.add(systemContralButtonPanel, BorderLayout.EAST); // arrange panels in window setLayout(new BorderLayout()); add(northPanel, BorderLayout.NORTH); add(centrelPanel, BorderLayout.CENTER); add(southPanel, BorderLayout.SOUTH); //statuesPanel // start listening for list and buttons events backupList.addListSelectionListener(new DisplayBackupProcessListener()); suspendList.addListSelectionListener(new DisplaySuspendedProcessListener()); readyList.addListSelectionListener(new DisplayreadyProcessListener()); addToBAKButton.addActionListener(new AddToBAKListener()); addToReadyButton.addActionListener(new AddToReadyListener()); resetButton.addActionListener(new ResetListener()); suspendButton.addActionListener(new SuspendListener()); umountButton.addActionListener(new UmountListener()); removeButton.addActionListener(new RemoveListener()); startButton.addActionListener(new StartSystemListener()); pauseButton.addActionListener(new SystemPauseListener()); resetSyatemButton.addActionListener(new ResetSystemListener()); priorityJRB.addActionListener(new priotiryListener()); timesliceJRB.addActionListener(new timeslicListener()); backupPCB = new PCBRecords(); readyPCB = new PCBRecords(); suspendedPCB = new PCBRecords(); memoryItems = new MemoryRecords(); MemoryItem initMemoryItem = new MemoryItem(0,3000); memoryItems.addItem(initMemoryItem); backupList.setListData(backupPCB.getItemsProperties()); readyList.setListData(readyPCB.getItemsProperties()); suspendList.setListData(suspendedPCB.getItemsProperties()); memoryList.setListData(memoryItems.getItemsProperties()); this.setTitle(\ this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setSize(WIDTH, HEIGHT); this.setResizable(true); this.setVisible(true); this.setLocation(200, 10); this.addWindowListener(new MyWindowMonitor()); }

public JPanel initPCBItemPanel() { JPanel iniPCBItemJPanel = new JPanel(new BorderLayout()); JPanel iniNamePanel = new JPanel(new GridLayout(6, 1));

JPanel iniValuePanel = new JPanel(new GridLayout(6, 1)); PIDLabel = new JLabel(\ requiredTimeLabel = new JLabel(\ priorityLabel = new JLabel(\ statuesLabel = new JLabel(\ baseLabel = new JLabel(\ limitLabel = new JLabel(\ iniNamePanel.add(PIDLabel); iniNamePanel.add(requiredTimeLabel); iniNamePanel.add(priorityLabel); iniNamePanel.add(statuesLabel); iniNamePanel.add(baseLabel); iniNamePanel.add(limitLabel); PIDTextField = new JTextField(\ PIDTextField.setEditable(true); requiredTimeTextField = new JTextField(\ requiredTimeTextField.setEditable(true); priorityTextField = new JTextField(\ priorityTextField.setEditable(true); statusTextField = new JTextField(\ statusTextField.setEditable(false); baseTextField = new JTextField(\ baseTextField.setEditable(false); limitTextField = new JTextField(\ limitTextField.setEditable(true); iniValuePanel.add(PIDTextField); iniValuePanel.add(requiredTimeTextField); iniValuePanel.add(priorityTextField); iniValuePanel.add(statusTextField); iniValuePanel.add(baseTextField); iniValuePanel.add(limitTextField); iniPCBItemJPanel.add(iniNamePanel, BorderLayout.WEST); iniPCBItemJPanel.add(iniValuePanel, BorderLayout.CENTER); return iniPCBItemJPanel; }

class MyWindowMonitor extends WindowAdapter { public void windowClosing(WindowEvent e) { System.exit(0); setVisible(false); } }

public void displayInformation(ProcessPCB pcb) { PIDTextField.setText(pcb.getPID()); requiredTimeTextField.setText(Integer.toString(pcb.getRequiredTime())); priorityTextField.setText(Integer.toString(pcb.getPriority())); statusTextField.setText(pcb.getStatus()); baseTextField.setText(Integer.toString(pcb.getMemoryBase())); limitTextField.setText(Integer.toString(pcb.getMemoryLimit())); }

//Displays the information of the selected PCBItem

class DisplayBackupProcessListener implements ListSelectionListener {

//

public void valueChanged(ListSelectionEvent event) { if (! backupList.getValueIsAdjusting()) { String id = null, selectedBAKItem = null; selectedBAKItem = (String) backupList.getSelectedValue(); if(selectedBAKItem != null) { StringTokenizer stringtokenizer = new StringTokenizer(selectedBAKItem, \ id = stringtokenizer.nextToken(); ProcessPCB backupItem = backupPCB.getItem(id); if(backupItem != null) { displayInformation(backupItem); } statuesTextArea.append(backupItem.toString() + \ + \ } } } }

class DisplaySuspendedProcessListener implements ListSelectionListener { }

public void valueChanged(ListSelectionEvent event) { if (! suspendList.getValueIsAdjusting()) { stdErr.flush(); String id = \ String str = (String) suspendList.getSelectedValue(); if(str != null) { StringTokenizer strtokenizer = new StringTokenizer(str, \ id = strtokenizer.nextToken(); ProcessPCB selectedSuspendedItem = suspendedPCB.getItem(id); if(selectedSuspendedItem != null) { displayInformation(selectedSuspendedItem); } statuesTextArea.append(selectedSuspendedItem.toString() + \ + \ } } }

class DisplayreadyProcessListener implements ListSelectionListener {

public void valueChanged(ListSelectionEvent event) { if (! readyList.getValueIsAdjusting()) { String id = null, s = null; s = (String) readyList.getSelectedValue(); if(s != null) { StringTokenizer sttokenizer = new StringTokenizer(s, \ id = sttokenizer.nextToken(); ProcessPCB readyItem = readyPCB.getItem(id); if(readyItem != null) { displayInformation(readyItem); } statuesTextArea.append(readyItem.toString() + \ + \

} } } }

//内存可分分区表排序，按可用内存大小降序排列 public void sortMemoryList() { MemoryRecords currentListItems = new MemoryRecords(); int num = memoryItems.getNumberOfItems(); if(num>0) { for(int i=num; i>=1; i--) { Iterator memoryIterator = memoryItems.iterator(); MemoryItem currentItem = (MemoryItem) memoryIterator.next(); for( ; memoryIterator.hasNext(); ) { MemoryItem nowItem = (MemoryItem) memoryIterator.next(); if(currentItem.getMemoryLimit() < nowItem.getMemoryLimit()) { currentItem = null; currentItem = nowItem; } } currentListItems.addItem(currentItem); memoryItems.removeItem(currentItem); } memoryItems = null; memoryItems = currentListItems; } memoryList.setListData(memoryItems.getItemsProperties()); }

//判断能否为进程分配内存

public boolean boolMemoryAllocation(int neededLimit) { if(memoryItems.getNumberOfItems()>0) { Iterator memoryListIteartor = memoryItems.iterator(); MemoryItem lagerestItem = (MemoryItem) memoryListIteartor.next(); if(lagerestItem.getMemoryLimit()>= neededLimit) return true; else { return false; } } else { return false; } }

//内存分配，按最先适应算法原则

public int MemoryAllocation(int neededLimit) { int currentBase=-1, currentLimit=-1; Iterator memoryListIteartor = memoryItems.iterator(); MemoryItem lagerestItem = (MemoryItem) memoryListIteartor.next(); currentBase = lagerestItem.getMemoryBase()+neededLimit; currentLimit = lagerestItem.getMemoryLimit()-neededLimit; memoryItems.removeItem(lagerestItem); if(currentLimit>0) { memoryItems.addItem(new MemoryItem(currentBase, currentLimit)); } sortMemoryList(); return lagerestItem.getMemoryBase(); }

//内存回收

public void memoryRecall(int nowBase, int nowLimit) { MemoryItem recallItem = null;

int recalledBase = nowBase; int recalledLimit = nowLimit; if(memoryItems.getNumberOfItems()>0) { Iterator memoryListIteartor = memoryItems.iterator(); for( ;memoryListIteartor.hasNext(); ) { MemoryItem existedItem = (MemoryItem) memoryListIteartor.next(); if(existedItem.getMemoryBase() == (nowBase+nowLimit)) { recalledLimit = recalledLimit+existedItem.getMemoryLimit(); memoryItems.removeItem(existedItem); memoryListIteartor = memoryItems.iterator(); } else if(nowBase == (existedItem.getMemoryBase()+existedItem.getMemoryLimit())) { recalledBase = existedItem.getMemoryBase(); recalledLimit = recalledLimit+existedItem.getMemoryLimit(); memoryItems.removeItem(existedItem); memoryListIteartor = memoryItems.iterator(); } //memoryListIteartor = memoryItems.iterator(); //注意此处代码曾引发异常 } //recallItem = new MemoryItem(recalledBase, recalledLimit); //曾产生异常 } recallItem = new MemoryItem(recalledBase, recalledLimit); memoryItems.addItem(recallItem); sortMemoryList(); }

public int readInteger(String s) { int num = -1; try { num = Integer.parseInt(s); } catch(NumberFormatException numberformatexception) { statuesTextArea.append(\ num = -999; } return num; }

public void addToBackupList(String newID, int s1, int s2, int s3, String s) { ProcessPCB item = backupPCB.getItem(newID); if(item != null) { statuesTextArea.append(\ + \ while(item != null) { newID = s + newID; item = backupPCB.getItem(newID); } }

ProcessPCB newPCB = new ProcessPCB(newID, s1, s2, \ backupPCB.addItem(newPCB);

backupList.setListData(backupPCB.getItemsProperties());

backupTotalTextField.setText(Integer.toString(backupPCB.getNumberOfItems())); }

public void addToReadyList(String nowID, int s1, int s2, int s3, String s) { ProcessPCB item = readyPCB.getItem(nowID); if(item != null) { statuesTextArea.append(\

+ \ while(item != null) {

nowID = s + nowID; item = backupPCB.getItem(nowID); } }

int s4=MemoryAllocation(s3); sortMemoryList();

ProcessPCB newPCB = new ProcessPCB(nowID, s1, s2, \ readyPCB.addItem(newPCB); sortReadyPCB(); }

class AddToBAKListener implements ActionListener { public void actionPerformed(ActionEvent event) { String newID = PIDTextField.getText(); String newTime = requiredTimeTextField.getText(); String newPriority = priorityTextField.getText(); String newLimit = limitTextField.getText(); int s1 = 0, s2 = 0, s3 = 0, tag1=-1, tag2=-1, tag3=-1; if(newTime != null) { s1 = readInteger(newTime); if(s1 > 0.0) tag1 = 1;

else statuesTextArea.append(\ } if(newPriority != null) { s2 = readInteger(newPriority); if(s1 != -999) tag2 = 1;

else statuesTextArea.append(\ } if(newLimit != null) { s3 = readInteger(newLimit); if(s3 > 0.0) tag3 = 1;

else statuesTextArea.append(\ } if(tag1 ==1 && tag2 == 1 && tag3 == 1) { if(newID == null) { statuesTextArea.append(\ } else { addToBackupList(newID, s1, s2, s3, \

statuesTextArea.append(\ reset(); } } } }

class AddToReadyListener implements ActionListener { public void actionPerformed(ActionEvent event) { String nowID = PIDTextField.getText(); String time = requiredTimeTextField.getText(); String priority = priorityTextField.getText(); String limit = limitTextField.getText(); int s1 = 0, s2 = 0, s3 =0; int tag1 = -1, tag2 = -1, tag3 = -1;

if(time != null) { s1 = readInteger(time); if(s1 > 0.0) tag1=1;

else statuesTextArea.append(\ } if(priority != null) { s2 = readInteger(priority); if(s2 != -999) tag2=1;

else statuesTextArea.append(\ } if(limit != null) { s3 = readInteger(limit); if(s3 > 0.0) tag3=1;

else statuesTextArea.append(\ }

if(tag1 ==1 && tag2 == 1 && tag3 ==1) { if(nowID == null) { statuesTextArea.append(\ } else {

// PCBItem item = null; if(readyPCB.getNumberOfItems() < 6) { if(boolMemoryAllocation(s3)) { addToReadyList(nowID, s1, s2, s3, \ statuesTextArea.append(\student recorditem has been added to ReadyList!\\n\ } else { statuesTextArea.append(\memory available! The PCB will be added to backupList!\\n\ addToBackupList(nowID, s1, s2, s3, \ statuesTextArea.append(\student recorditem has been added to BackupList!\\n\ } } else { statuesTextArea.append(\ReadyList was full! The new ProcessPCB will be added to BackupList!\\n\ addToBackupList(nowID, s1, s2, s3, \ statuesTextArea.append(\ } reset(); } } } }

public void reset() { PIDTextField.setText(\ requiredTimeTextField.setText(\ priorityTextField.setText(\ statusTextField.setText(\ baseTextField.setText(\ limitTextField.setText(\ }

// This inner class processes resetButton events. class ResetListener implements ActionListener {

public void actionPerformed(ActionEvent event) { reset(); } }

// This inner class processes suspendButton events.

//注：在挂起时，不会触发进程调度，而是在点击\时才会出发进程调度 class SuspendListener implements ActionListener { public void actionPerformed(ActionEvent event) { String selectedReadyItem = null; String pid = \ if(readyPCB.getNumberOfItems() == 0) { statuesTextArea.append(\ } else { try {

selectedReadyItem = (String) readyList.getSelectedValue(); if(selectedReadyItem == null) {

statuesTextArea.append(\ } else {

StringTokenizer stringtokenizer = new StringTokenizer(selectedReadyItem, \ pid = stringtokenizer.nextToken(); ProcessPCB selectedItem = readyPCB.getItem(pid); if(selectedItem == null) { statuesTextArea.append(\student recorditem of Num \+ pid + \is founded!\\n\

} else { ProcessPCB boolItem = suspendedPCB.getItem(pid); if(boolItem != null) { statuesTextArea.append(\ + \ while(boolItem != null) { pid = \ boolItem = suspendedPCB.getItem(pid); } } //注意下一步存在问题！ ProcessPCB newPcb = new ProcessPCB(pid, selectedItem.getRequiredTime(), selectedItem.getPriority(),\-1, selectedItem.getMemoryLimit()); memoryRecall(selectedItem.getMemoryBase(), selectedItem.getMemoryLimit()); suspendedPCB.addItem(newPcb); readyPCB.removeItem(selectedItem); // if(systemStatues == 1) { // PCBSchudling(); // } sortReadyPCB(); suspendList.setListData(suspendedPCB.getItemsProperties()); statuesTextArea.append(\

suspendTotalTextField.setText(Integer.toString(suspendedPCB.getNumberOfItems())); } }

} catch (RuntimeException e1) { // TODO Auto-generated catch block } } }

}

//对Ready队列进行优先级排序 public void sortReadyPCB() { PCBRecords currentReadyPCB = new PCBRecords(); int num = readyPCB.getNumberOfItems(); if(num > 0) { for(int i=num; i>=1; i--) { Iterator readyIterator = readyPCB.iterator(); ProcessPCB currentItem = (ProcessPCB) readyIterator.next(); for( ; readyIterator.hasNext(); ) { ProcessPCB nowItem = (ProcessPCB) readyIterator.next(); if(currentItem.getPriority() < nowItem.getPriority()) { currentItem = null; currentItem = nowItem; } } currentReadyPCB.addItem(currentItem); readyPCB.removeItem(currentItem); } readyPCB = null; readyPCB = currentReadyPCB; } readyList.setListData(readyPCB.getItemsProperties()); }

// This inner class processes umountButton events. class UmountListener implements ActionListener { public void actionPerformed(ActionEvent event) { String selectedSuspendedItem = null; String id = \ if(suspendedPCB.getNumberOfItems() == 0) { statuesTextArea.append(\ } else { try { selectedSuspendedItem = (String) suspendList.getSelectedValue(); if(selectedSuspendedItem == null) {

statuesTextArea.append(\ } else {

StringTokenizer stringtokenizer = new StringTokenizer(selectedSuspendedItem, \ id = stringtokenizer.nextToken(); ProcessPCB selectedItem = suspendedPCB.getItem(id); if(selectedItem == null) { statuesTextArea.append(\ } else { int s3 = selectedItem.getMemoryLimit(); if(readyPCB.getNumberOfItems() < 6) {

if(boolMemoryAllocation(s3)) { addToReadyList(id, selectedItem.getRequiredTime(), selectedItem.getRequiredTime(), s3, \ statuesTextArea.append(\product has been Umounted to Ready List!\\n\

} else { statuesTextArea.append(\memory available! The PCB will be Umounted to BackupList!\\n\ addToBackupList(id, selectedItem.getRequiredTime(), selectedItem.getRequiredTime(), s3, \

statuesTextArea.append(\product has been Umounted to Backup List!\\n\

} } else { statuesTextArea.append(\be Umounted to BackupList!\\n\ addToBackupList(id, selectedItem.getRequiredTime(), selectedItem.getRequiredTime(), s3, \ statuesTextArea.append(\product has been Umounted to Backup List!\\n\

} suspendedPCB.removeItem(selectedItem); suspendList.setListData(suspendedPCB.getItemsProperties());

suspendTotalTextField.setText(Integer.toString(suspendedPCB.getNumberOfItems())); } }

} catch (RuntimeException e1) { // TODO Auto-generated catch block } } } } /**

* This inner class processes removeButton events. */

public int getTimeslice() { return timeslice; }

class RemoveListener implements ActionListener { public void actionPerformed(ActionEvent event) { String selectedRemovsItem = null; String id = \ if(suspendedPCB.getNumberOfItems() == 0) { statuesTextArea.append(\ } else {

selectedRemovsItem = (String) suspendList.getSelectedValue(); if(selectedRemovsItem == null) {

statuesTextArea.append(\ } else {

StringTokenizer stringtokenizer = new StringTokenizer(selectedRemovsItem, \ id = stringtokenizer.nextToken(); ProcessPCB suspendedItem = suspendedPCB.getItem(id); if(suspendedItem == null) { statuesTextArea.append(\ } else { suspendedPCB.removeItem(suspendedItem); suspendList.setListData(suspendedPCB.getItemsProperties()); statuesTextArea.append(\ }

suspendTotalTextField.setText(Integer.toString(suspendedPCB.getNumberOfItems())); } } } }

//内存进程调度 public void PCBSchudling() { while(readyPCB.getNumberOfItems() < 6) { if(backupPCB.getNumberOfItems() > 0) { Iterator bwackupPCBIterator = backupPCB.iterator(); ProcessPCB newItem = (ProcessPCB) bwackupPCBIterator.next(); readyPCB.addItem(newItem); backupPCB.removeItem(newItem); sortReadyPCB(); readyList.setListData(readyPCB.getItemsProperties()); backupList.setListData(backupPCB.getItemsProperties()); backupTotalTextField.setText(Integer.toString(backupPCB.getNumberOfItems())); } else break; } } /*

public void run() { PCBSchudling(); if(readyPCB.getNumberOfItems() > 0) { Iterator readyIterator = readyPCB.iterator(); PCBItem runningItem = (PCBItem) readyIterator.next(); if(runningItem.getPCB().getRequiredTime()>0) { runningItem.run(); } if(runningItem.getPCB().getRequiredTime() <= 0) { statuesTextArea.append(\work has been finished and the PCB will be moved out from the memory!\\n\ readyPCB.removeItem(runningItem); runningItem = null; //注意 PCBSchudling(); } sortReadyPCB(); readyList.setListData(readyPCB.getItemsProperties()); } else { statuesTextArea.append(\ // System.exit(0); } } */

class RunThread extends Thread { int t, TimeSlice; boolean Flag = true; public void run(){ while(Flag) { //Warning!!!!!!!!!!!! if(getSystemStatus() == 0) { Flag = false; break; } else if(getSystemStatus() == 2) { while(getSystemStatus() == 2) { try {

Thread.sleep(1000); } catch (Exception ee) { ee.printStackTrace(); } } } if(readyPCB.getNumberOfItems() < 6) { if(backupPCB.getNumberOfItems() > 0) { while(readyPCB.getNumberOfItems() < 6) { if(backupPCB.getNumberOfItems() > 0) { Iterator bwackupPCBIterator = backupPCB.iterator(); ProcessPCB newItem = (ProcessPCB) bwackupPCBIterator.next(); while(bwackupPCBIterator.hasNext() ) { int s = newItem.getMemoryLimit(); if (boolMemoryAllocation(s)) { break; } else newItem = (ProcessPCB) bwackupPCBIterator.next(); if(newItem == null) break; } if(newItem != null) { int bbase=0; int llimit = newItem.getMemoryLimit(); bbase = MemoryAllocation(llimit); ProcessPCB nowItem = new ProcessPCB(newItem.getPID(), newItem.getRequiredTime(), newItem.getPriority(), \bbase, llimit); readyPCB.addItem(nowItem); backupPCB.removeItem(newItem); backupList.setListData(backupPCB.getItemsProperties());

backupTotalTextField.setText(Integer.toString(backupPCB.getNumberOfItems())); } else { statuesTextArea.append(\ break; } } else break; } } } sortReadyPCB(); backupList.setListData(backupPCB.getItemsProperties()); backupTotalTextField.setText(Integer.toString(backupPCB.getNumberOfItems())); Iterator readyIterator = readyPCB.iterator(); ProcessPCB runningItem = null; if(readyIterator.hasNext()) { runningItem = (ProcessPCB) readyIterator.next(); } //PCBItem runningItem = (PCBItem) readyIterator.next(); //readyPCB.getNumberOfItems() > 0 //注意此处有bug结果就出现了java.util.NoSuchElementException的错误提示 ，就是黄色的那一句，多了一个 迭代器的next（）。 if(runningItem != null) { t = runningItem.getRequiredTime(); TimeSlice = getTimeslice(); System.out.println(TimeSlice);

for(int i=TimeSlice; i>=0; i--) { if(t >= 0) { runningItem.run(); t--; sortReadyPCB(); if(getFlag() == true) CPUTextArea.append(\PCB \+ runningItem.getPID() + \is running!\\n\ try { Thread.sleep(990); } catch (Exception ee) { ee.printStackTrace(); } } } if(t < 0) { Flag = false; statuesTextArea.append(\from the memory!\\n\ memoryRecall(runningItem.getMemoryBase(), runningItem.getMemoryLimit()); readyPCB.removeItem(runningItem); runningItem = null; sortReadyPCB(); } if(readyPCB.getNumberOfItems() > 0) Flag = getFlag(); else Flag = false; } else Flag = false; //Warning!!!!!!!!!!!!!!!! if(getSystemStatus() == 0) { Flag = false; break; } else { if(getSystemStatus() == 2) { while(getSystemStatus() == 2) { try { Thread.sleep(1000); } catch (Exception ee) { ee.printStackTrace(); } } } if(getSystemStatus() == 1) Flag = true; } } } }

public boolean getFlag() { return this.flag; }

public int getSystemStatus() { return systemStatus; }

class StartSystemListener implements ActionListener {

public void actionPerformed(ActionEvent event) { if(readyPCB.getNumberOfItems() > 0) { if(systemStatus == 0) { Thread runThread = new RunThread(); flag = true; runThread.start(); systemStatus = 1; statuesTextArea.append(\ } else { statuesTextArea.append(\ } } else statuesTextArea.append(\ } }

class SystemPauseListener implements ActionListener { public void actionPerformed(ActionEvent event) { if(systemStatus == 1) { flag = false; systemStatus = 2; pauseButton.setText(\ statuesTextArea.append(\ } else if(systemStatus == 2) { flag = true; systemStatus = 1; pauseButton.setText(\ statuesTextArea.append(\ } else { statuesTextArea.append(\ } } }

class ResetSystemListener implements ActionListener { public void actionPerformed(ActionEvent event) { if(systemStatus != 0) { flag = false;

systemStatus = 0;

backupPCB = null; readyPCB = null; suspendedPCB = null; memoryItems = null;

backupPCB = new PCBRecords(); readyPCB = new PCBRecords(); suspendedPCB = new PCBRecords(); backupList.setListData(backupPCB.getItemsProperties()); readyList.setListData(readyPCB.getItemsProperties()); suspendList.setListData(suspendedPCB.getItemsProperties()); backupTotalTextField.setText(\ suspendTotalTextField.setText(\ CPUTextArea.setText(\ statuesTextArea.setText(\ priorityJRB.doClick(); timeslice = 1;

timesliceJtf.setText(\

memoryItems = new MemoryRecords(); memoryList.removeAll(); MemoryItem newMemoryItem = new MemoryItem(0,3000); memoryItems.addItem(newMemoryItem);

memoryList.setListData(memoryItems.getItemsProperties()); statuesTextArea.append(\ } else { statuesTextArea.append(\ } } }

class priotiryListener implements ActionListener { public void actionPerformed(ActionEvent event) { timeslice = 1; } }

class timeslicListener implements ActionListener { public void actionPerformed(ActionEvent event) { timeslice = getTimesliceText(); if(timeslice <= 0) { statuesTextArea.append(\ timesliceJtf.setText(\ timeslice = 1; } } }

public int getTimesliceText() { int n; try { n = Integer.parseInt(timesliceJtf.getText()); } catch(NumberFormatException numberformatexception) { statuesTextArea.append(\ n = -999; } return n; } }

Word文档下载：操作系统实验-CPU进程调度和内存分配 - java版.doc
搜索更多:操作系统实验-CPU进程调度和内存分配 - java版


最新浏览


热门浏览
All rights reserved Powered by 南京廖华答案网　
资料来自互联网， 有任何疑问，请联系客服：779662525☒qq.com 苏ICP备20003344号-2