java分时排队系统,java操作系统优先级跟分时调度算法

骑猪看日落 2023-01-13 04:17 30阅读 0赞

java操作系统优先级和分时调度算法

事先声明;本代码并非原创，这里发出来仅供大家参考学习；本人在研究之后，对原著稍作改动，如有不喜，倍感抱歉！

以下代码按照一定顺序发送，就不多解释了。

package CPU;

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.getRequiredTime() + "\_" + this.getPriority() + "\_"

\+ this.getStatus() + "\_" + this.getMemoryBase() + "\_" + this.getMemoryLimit() + "\\n";

public void run() \{

this.RequiredTime = this.RequiredTime-1;

this.Priority = this.Priority-1;

package CPU;

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();

package CPU;

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() + "\_" + this.getMemoryLimit() + "\\n";

package CPU;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Cursor;

import java.awt.Font;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import java.io.IOException;

import java.io.PrintWriter;

import java.util.Iterator;

import java.util.StringTokenizer;

import javax.swing.BorderFactory;

import javax.swing.ButtonGroup;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JPanel;

import javax.swing.JRadioButton;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

public class SingleCPUSchedulingGUI03 extends JFrame \{

/\*\*

\*/

private static final long serialVersionUID = -6748846647033499999L;

/\* 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 = 2; //内存队列

static private int CPU\_ROWS = 2, CPU\_COLS = 2; //CPU面板

static private int STATUS\_ROWS = 8, STATUS\_COLS = 35; //系统状态面板

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; //各队列相对应的数组列表

//进程添加框中的"添加至后备队列"，"添加至就绪队列"，"重置"Button

private JButton addToBAKButton, addToReadyButton, resetButton;

//就绪队列框中的"挂起"，挂起队列框中的"解挂"，"删除"Button

private JButton suspendButton, umountButton, removeButton;

//Status面板中的"启动系统"，"重置系统"Button

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("优先级", true);

timesliceJRB = new JRadioButton("时间片");

backupTotalLabel = new JLabel("总计:");

backupTotalTextField = new JTextField("0", TOTAL\_\_TEXTFIELD\_SIZE);

backupTotalTextField.setEditable(false);

suspendTotalLabel = new JLabel("总计:");

suspendTotalTextField = new JTextField("0", TOTAL\_\_TEXTFIELD\_SIZE);

suspendTotalTextField.setEditable(false);

timesliceSizeLabel = new JLabel("时间片:");

timesliceJtf = new JTextField("3", 5);

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("PCB项目信息"));

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());

JTable jtb = new JTable(1, 6);

jtb.setRowHeight(30);

jtb.setEnabled(false);

jtb.setGridColor(Color.BLUE);

String\[\] str =\{"name","time","priority","status","base","limit"\};

for(int i = 0;i<6;i++)\{

jtb.setValueAt(str\[i\], 0, i);

backupBAKPanel.setBorder(BorderFactory.createTitledBorder("后备队列"));

backupList.setCursor(Cursor.getPredefinedCursor(Cursor.HAND\_CURSOR));

JPanel backupTotalPAnel = new JPanel();

backupTotalPAnel.add(backupTotalLabel);

backupTotalPAnel.add(backupTotalTextField);

backupBAKPanel.add(jtb,BorderLayout.NORTH);

backupList.setBackground(Color.YELLOW);

backupList.setFont(new Font(null, Font.BOLD,18));

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);

suspendList.setBackground(new Color(0, 255, 0));

suspendList.setFont(new Font(null, Font.BOLD,18));

suspendList.setCursor(Cursor.getPredefinedCursor(Cursor.HAND\_CURSOR));

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("就绪队列"));

readyList.setBackground(Color.PINK);

readyList.setFont(new Font(null, Font.BOLD,18));

readyList.setCursor(Cursor.getPredefinedCursor(Cursor.HAND\_CURSOR));

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(new BorderLayout());

CPUPanel.setBorder(BorderFactory.createTitledBorder("CPU-运行"));

JLabel jl=new JLabel(new ImageIcon("2.gif"));

CPUPanel.add(jl,BorderLayout.CENTER);

CPUTextArea.setFont(new Font(null, Font.BOLD,18));

CPUPanel.add (new JScrollPane(CPUTextArea,

JScrollPane.VERTICAL\_SCROLLBAR\_AS\_NEEDED,

JScrollPane.HORIZONTAL\_SCROLLBAR\_AS\_NEEDED),BorderLayout.NORTH);

memoryPanel = new JPanel(new BorderLayout());

memoryPanel.setBorder(BorderFactory.createTitledBorder("内存列表(正被占用内存——剩余内存)"));

JLabel jl1=new JLabel(new ImageIcon("8.gif"));

memoryList.setFont(new Font(null, Font.BOLD,18));

memoryPanel.add(jl1,BorderLayout.CENTER);

memoryPanel.add (

new JScrollPane(memoryList,

JScrollPane.VERTICAL\_SCROLLBAR\_AS\_NEEDED,

JScrollPane.HORIZONTAL\_SCROLLBAR\_AS\_NEEDED),BorderLayout.NORTH);

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("状态"));

statuesTextArea.setBackground(Color.ORANGE);

statuesTextArea.setFont(new Font(null, Font.BOLD,18));

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("CPU调度");

this.setIconImage(new ImageIcon("4.gif").getImage());//添加方框的图标

this.setDefaultCloseOperation(JFrame.EXIT\_ON\_CLOSE);

this.setSize(WIDTH, HEIGHT);

this.setResizable(true);

this.setVisible(true);

this.setLocationRelativeTo(null);

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("PID:");

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("", 10);

PIDTextField.setEditable(true);

requiredTimeTextField = new JTextField("", 10);

requiredTimeTextField.setEditable(true);

priorityTextField = new JTextField("", 10);

priorityTextField.setEditable(true);

statusTextField = new JTextField("", 10);

statusTextField.setEditable(false);

baseTextField = new JTextField("", 10);

baseTextField.setEditable(false);

limitTextField = new JTextField("", 10);

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() + "进程 " + id

\+ "加入后备队列了!\\n");

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() + "进程 " + id

\+ "加入挂起队列了!\\n");

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() + "进程 " + id

\+ "加入就绪队列了!\\n");

//内存可分分区表排序，按可用内存大小降序排列

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("请输入一个正整数!\\n");

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("PCB " + newID + " 已经存在于后备队列了!\\n"

\+ "你需要去改变所选PCB的PID!\\n");

while(item != null) \{

newID = s + newID;

item = backupPCB.getItem(newID);

ProcessPCB newPCB = new ProcessPCB(newID, s1, s2, "Waiting", -1, s3);

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("PCB " + nowID + " 已经存在于就绪队列了!\\n"

\+ "你需要去改变所选PCB的PID!\\n");

while(item != null) \{

nowID = s + nowID;

item = backupPCB.getItem(nowID);

int s4=MemoryAllocation(s3);

sortMemoryList();

ProcessPCB newPCB = new ProcessPCB(nowID, s1, s2, "Ready", s4, s3);

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("所需时间必须是个正整数.\\n");

if(newPriority != null)

s2 = readInteger(newPriority);

if(s1 != -999) tag2 = 1;

else statuesTextArea.append("优先级必须是个正整数.\\n");

if(newLimit != null)

s3 = readInteger(newLimit);

if(s3 > 0.0) tag3 = 1;

else statuesTextArea.append("所需内存大小必须是个正整数.\\n");

if(tag1 ==1 && tag2 == 1 && tag3 == 1) \{

if(newID == null) \{

statuesTextArea.append("ID不能为空!\\n");

\} else \{

addToBackupList(newID, s1, s2, s3, "B");

statuesTextArea.append("PCB的信息加入后备队列里!\\n");

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("所需时间必须是个正整数.\\n");

if(priority != null)

s2 = readInteger(priority);

if(s2 != -999) tag2=1;

else statuesTextArea.append("优先级必须是个正整数.\\n");

if(limit != null)

s3 = readInteger(limit);

if(s3 > 0.0) tag3=1;

else statuesTextArea.append("所需内存大小必须是个正整数.\\n");

if(tag1 ==1 && tag2 == 1 && tag3 ==1) \{

if(nowID == null) \{

statuesTextArea.append("ID不能为空!\\n");

\} else \{

// PCBItem item = null;

if(readyPCB.getNumberOfItems() < 6) \{

if(boolMemoryAllocation(s3)) \{

addToReadyList(nowID, s1, s2, s3, "R");

statuesTextArea.append("进程加入就绪队列!\\n");

\} else \{

statuesTextArea.append("内存空间不足! PCB将被加载入后备队列!\\n");

addToBackupList(nowID, s1, s2, s3, "b");

statuesTextArea.append("进程加入后备队列!\\n");

\} else \{

statuesTextArea.append("就绪队列已满! 新的进程将被加载入后备队列!\\n");

addToBackupList(nowID, s1, s2, s3, "b");

statuesTextArea.append("进程加入后备队列!\\n");

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.

//注：在挂起时，不会触发进程调度，而是在点击"startSyatemJButton"时才会出发进程调度

class SuspendListener implements ActionListener \{

public void actionPerformed(ActionEvent event) \{

String selectedReadyItem = null;

String pid = "";

if(readyPCB.getNumberOfItems() == 0)

statuesTextArea.append("就绪队列为空!\\n");

\} else \{

try \{

selectedReadyItem = (String) readyList.getSelectedValue();

if(selectedReadyItem == null) \{

statuesTextArea.append("请选择一个进程放入就绪队列!\\n");

\} else

StringTokenizer stringtokenizer = new StringTokenizer(selectedReadyItem, "\_");

pid = stringtokenizer.nextToken();

ProcessPCB selectedItem = readyPCB.getItem(pid);

if(selectedItem == null) \{

statuesTextArea.append("进程 " + pid + " 不存在!\\n");

\} else \{

ProcessPCB boolItem = suspendedPCB.getItem(pid);

if(boolItem != null) \{

statuesTextArea.append("PCB " + pid + " 已经存在于挂起队列!\\n"

\+ "你需要去修改所选择的PCB的PID!\\n");

while(boolItem != null) \{

pid = "S" + pid;

boolItem = suspendedPCB.getItem(pid);

//注意下一步存在问题！

ProcessPCB newPcb = new ProcessPCB(pid, selectedItem.getRequiredTime(),

selectedItem.getPriority(),"Suspended", -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("进程已被挂起!\\n");

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("挂起队列为空!\\n");

\} else \{

try \{

selectedSuspendedItem = (String) suspendList.getSelectedValue();

if(selectedSuspendedItem == null) \{

statuesTextArea.append("请从挂起队列里面选择一个进程!\\n");

\} else

StringTokenizer stringtokenizer = new StringTokenizer(selectedSuspendedItem, "\_");

id = stringtokenizer.nextToken();

ProcessPCB selectedItem = suspendedPCB.getItem(id);

if(selectedItem == null) \{

statuesTextArea.append("进程 " + id + " 不存在!\\n");

\} else \{

int s3 = selectedItem.getMemoryLimit();

if(readyPCB.getNumberOfItems() < 6) \{

if(boolMemoryAllocation(s3)) \{

addToReadyList(id, selectedItem.getRequiredTime(),

selectedItem.getRequiredTime(), s3, "r");

statuesTextArea.append("进程已被解挂进入了就绪队列!\\n");

\} else \{

statuesTextArea.append("内存空间不足! PCB将被解挂进入后备队列!\\n");

addToBackupList(id, selectedItem.getRequiredTime(),

selectedItem.getRequiredTime(), s3, "II");

statuesTextArea.append("进程已被解挂入后备队列!\\n");

\} else \{

statuesTextArea.append("就绪队列已满! 新的进程将被解挂进入后备队列!\\n");

addToBackupList(id, selectedItem.getRequiredTime(),

selectedItem.getRequiredTime(), s3, "II");

statuesTextArea.append("进程已被解挂入后备队列!\\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("记录为空!\\n");

\} else

selectedRemovsItem = (String) suspendList.getSelectedValue();

if(selectedRemovsItem == null) \{

statuesTextArea.append("ID不能为空!\\n");

\} else \{

StringTokenizer stringtokenizer = new StringTokenizer(selectedRemovsItem, "\_");

id = stringtokenizer.nextToken();

ProcessPCB suspendedItem = suspendedPCB.getItem(id);

if(suspendedItem == null) \{

statuesTextArea.append("进程" + id + " 不存在!\\n");

\} else \{

suspendedPCB.removeItem(suspendedItem);

suspendList.setListData(suspendedPCB.getItemsProperties());

statuesTextArea.append("进程已被移除!\\n");

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;

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(),

"Ready", bbase, llimit);

readyPCB.addItem(nowItem);

backupPCB.removeItem(newItem);

backupList.setListData(backupPCB.getItemsProperties());

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

\} else \{

statuesTextArea.append("内存空间不足!\\n");

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();

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.setText("");

CPUTextArea.append("PCB " + runningItem.getPID() + " is running!\\n");

try \{

Thread.sleep(990);

\} catch (Exception ee) \{

ee.printStackTrace();

if(t < 0) \{

Flag = false;

statuesTextArea.append("该进程执行完成并且相应的PCB将从内存中移除!\\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("调度开始!\\n");

\} else \{

statuesTextArea.append("重置完成!\\n");

\} else statuesTextArea.append("就绪队列为空，请加入进程\\n");

class SystemPauseListener implements ActionListener \{

public void actionPerformed(ActionEvent event) \{

if(systemStatus == 1) \{

flag = false;

systemStatus = 2;

pauseButton.setText("继续");

statuesTextArea.append("暂停!\\n");

\} else if(systemStatus == 2) \{

flag = true;

systemStatus = 1;

pauseButton.setText("暂停");

statuesTextArea.append("系统继续!\\n");

\} else \{

statuesTextArea.append("错误操作!\\n");

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("0");

suspendTotalTextField.setText("0");

CPUTextArea.setText("");

statuesTextArea.setText("");

priorityJRB.doClick();

timeslice = 1;

timesliceJtf.setText("3");

memoryItems = new MemoryRecords();

memoryList.removeAll();

MemoryItem newMemoryItem = new MemoryItem(0,3000);

memoryItems.addItem(newMemoryItem);

memoryList.setListData(memoryItems.getItemsProperties());

statuesTextArea.append("系统重置!\\n");

\} else \{

statuesTextArea.append("错误操作!\\n");

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("时间片必须是个正整数!\\n");

timesliceJtf.setText("1");

timeslice = 1;

public int getTimesliceText() \{

int n;

try \{

n = Integer.parseInt(timesliceJtf.getText());

\} catch(NumberFormatException numberformatexception) \{

statuesTextArea.append("时间片必须是个正整数!\\n");

n = -999;

return n;

package CPU;

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;

![215901363.png][]

欢迎新手提问！！！

[215901363.png]: http://www.myexceptions.net/img/2014/11/15/215901363.png

java分时排队系统,java操作系统优先级跟分时调度算法

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关物联网系统和操作系统的差距_实时操作系统和分时操作系统之间的差异

相关 java分时排队系统,java操作系统优先级跟分时调度算法

相关实时操作系统与分时操作系统的区别

相关磁盘调度算法 java_操作系统磁盘调度算法 java版

相关 java 先入先出_Java_操作系统的先进先出调度算法,优先级调度算法

相关 Linux是实时系统还是分时操作系统?

相关批处理系统、分时处理系统、实时处理系统简介

相关 nginx日志分时切割

相关 java分页算法

相关 OSD-04016: 异步 I/O 请求排队时出错----惜分飞