Swing实现：模拟优先级CPU调度与内存管理（2）

mainFrame.java

__________________________________

import java.awt.*;
import java.awt.event.*;
import java.util.Vector;


import javax.swing.*;
import javax.swing.table.*;


public class mainFrame extends JFrame implements ActionListener,Runnable {
//后备队列，运行队列，挂起队列
JTable table1,table2,table3;
int total,used,remain;
JScrollPane s1,s2,s3,s4;
JLabel label1,label2,label3,label4;
JButton button1,button2,button3;
JTextArea event;
JLabel totalLabel,usedLabel,remainLabel;
JTextArea totalArea,usedArea,remainArea;
//用数组记录内存分配情况
int[] memory = new int[1000];
//创建队列
public queue runningQueue = new queue(this);
public queue reserveQueue = new queue(this);
public queue suspendQueue = new queue(this);
//创建进程窗口
public addProcess addFrame = new addProcess(this);
public mainFrame(){
super("优先级进程调度");
total = 1000;
used = 0;
remain = 1000;
Container contentPane = this.getContentPane();
contentPane.setLayout(null);
//初始化内存数组
for(int i = 0;i <= 999;i++){
memory[i] = 0;
}
Font font = new Font("微软雅黑",0,18);
table1 = new JTable(20,4);
table2 = new JTable(20,4);
table3 = new JTable(20,4);
table1.setRowHeight(25);
table2.setRowHeight(25);
table3.setRowHeight(25);
table1.setFont(font);
table2.setFont(font);
table3.setFont(font);
event = new JTextArea();
s1 = new JScrollPane(table1);
s2 = new JScrollPane(table2);
s3 = new JScrollPane(table3);
s4 = new JScrollPane(event);

s1.setBounds(50, 50, 350, 250);
s2.setBounds(450, 50, 300, 100);
s3.setBounds(450, 300, 300, 200);
s4.setBounds(50, 350, 350, 150);
totalLabel = new JLabel("所有内存");
usedLabel = new JLabel("已用内存");
remainLabel = new JLabel("剩余内存");
totalArea = new JTextArea();
usedArea = new JTextArea();
remainArea = new JTextArea();
totalLabel.setBounds(450, 50, 300, 240);
usedLabel.setBounds(450, 50, 300, 300);
remainLabel.setBounds(450, 50, 300, 360);
totalArea.setBounds(520, 160, 100, 30);
usedArea.setBounds(520, 190, 100, 30);
remainArea.setBounds(520, 220, 100, 30);
label1 = new JLabel("正在运行");
label1.setBounds(50, 0, 100, 50);
label2 = new JLabel("挂起队列");
label2.setBounds(450, 0, 100, 50);
label3 = new JLabel("后备队列");
label3.setBounds(450, 250, 100, 50);
label4 = new JLabel("事件");
label4.setBounds(50, 300, 100, 50);

button1 = new JButton("添加进程");
button2 = new JButton("全部开始");
button3 = new JButton("全部停止");

button1.setBounds(150, 550, 100, 50);
button1.addActionListener(this);
button2.setBounds(300, 550, 100, 50);
button3.setBounds(450, 550, 100, 50);
button3.addActionListener(this);

contentPane.add(s1);
contentPane.add(label1);
contentPane.add(s2);
contentPane.add(label2);
contentPane.add(s3);
contentPane.add(label3);
contentPane.add(s4);
contentPane.add(label4);
contentPane.add(button1);
contentPane.add(button2);
contentPane.add(button3);
contentPane.add(totalLabel);
contentPane.add(usedLabel);
contentPane.add(remainLabel);
contentPane.add(totalArea);
contentPane.add(usedArea);
contentPane.add(remainArea);

this.setBounds(250, 20, 800, 700);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}





public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(e.getSource() ==button1){
addFrame.setVisible(true);
//打印队列
System.out.println(this.reserveQueue.rear);
System.out.println(this.reserveQueue.length);
for(int i = 0;i <=this.reserveQueue.rear;i++){
System.out.println(this.reserveQueue.processQueue[i].processName);
}
}
if(e.getSource() == button3){
runningQueue.clear();
reserveQueue.clear();
suspendQueue.clear();
}
}


@SuppressWarnings("unchecked")
public void run() {
// TODO Auto-generated method stub

while(true){
totalArea.setText(total + "");
usedArea.setText(used + "");
remainArea.setText(remain + "");
//更新后备队列显示
//复制队列，防止出现进程之间的干扰(浅克隆)
queue q1 = this.reserveQueue;
//v1是一行的数据，v2是所有行的集合，v3是列名
Vector v2 = new Vector(100);
for(int i = q1.head;i <= q1.rear;i++){
Vector v1=new Vector(100);
if(q1.processQueue[i] != null){
v1.addElement(q1.processQueue[i].processName);
v1.addElement(q1.processQueue[i].pid + "");
v1.addElement(q1.processQueue[i].priority + "");
v1.addElement(q1.processQueue[i].needMemory + "");
v2.addElement(v1);
}
} 
if(q1.head <= q1.rear){
Vector v3 = new Vector(100);
v3.addElement("processName");
v3.addElement("pid");
v3.addElement("prioty");
v3.addElement("needMemory");


DefaultTableModel model=new DefaultTableModel(v2,v3);


table3.setModel(model);
table3.repaint();
table3.updateUI();


}
//更新运行队列
if(!this.runningQueue.isFull() && !this.reserveQueue.isEmpty()){
//选取后备队列中优先级最高的进入运行队列
runningQueue.addNewProcess(reserveQueue.processQueue[reserveQueue.select()],true);
PCB p = reserveQueue.processQueue[reserveQueue.select()];
int endMemory = p.beginMemory + p.needMemory - 1;
event.append(reserveQueue.processQueue[reserveQueue.select()].processName + "从后备队列进入运行队列\n");
event.append(p.processName + "进程分配内存为" + p.beginMemory + "~" + endMemory + "\n");
reserveQueue.leave(reserveQueue.select(),false);
}
//更新运行队列显示
//复制队列，防止出现进程之间的干扰(浅克隆)
queue q2 = this.runningQueue;
//v1是一行的数据，v2是所有行的集合，v3是列名
v2 = new Vector(100);
for(int i = q2.head;i <= q2.rear;i++){
Vector v1=new Vector(100);
if(q2.processQueue[i] != null){
v1.addElement(q2.processQueue[i].processName);
v1.addElement(q2.processQueue[i].pid + "");
v1.addElement(q2.processQueue[i].priority + "");
v1.addElement(q2.processQueue[i].needMemory + "");
v2.addElement(v1);
}
} 
if(q2.head <= q2.rear){
Vector v3 = new Vector(100);
v3.addElement("processName");
v3.addElement("pid");
v3.addElement("prioty");
v3.addElement("needMemory");


DefaultTableModel model2 =new DefaultTableModel(v2,v3);


table1.setModel(model2);
table1.repaint();
table1.updateUI();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();}
}
runningQueue.running();
}

}
}


queue.java

___________________________________

public class queue {
public PCB[] processQueue = new PCB[100];
int head;
int rear;
int length;
int allocatePid;
int capacity;
mainFrame mf;
public queue(mainFrame f){
head = 0;
rear = -1;
length = 0;
allocatePid = 0;
capacity = 15;
mf = f;
}

public queue(int capacity){
this.capacity = capacity;
head = 0;
rear = -1;
length = 0;
allocatePid = 0;
}
//入列，构建循环队列
public void addNewProcess(PCB newProcess,boolean isAllocated){
int position = rear + 1;
System.out.println("position" + position);
processQueue[position] = newProcess;
rear++;
length ++;
allocatePid ++;
//根据不同的要求决定是否分配内存
if(isAllocated){
//寻找可用的孔
for(int i = 0;i < 1000;i ++){
if(check(i,newProcess.needMemory)){
newProcess.beginMemory = i;
break;
}
}
//分配内存
if(newProcess.beginMemory == -1){
System.out.println("有进程无法被分配内存！！");
}
else{
for(int i = newProcess.beginMemory;i < newProcess.beginMemory + newProcess.needMemory;i++){
mf.memory[i] = 1;
}
mf.used = mf.used + newProcess.needMemory;
mf.remain = mf.remain - newProcess.needMemory;
}
}
}
public boolean isEmpty(){
return length == 0;
}
public boolean isFull(){
return length == capacity;
}
//出列
public void leave(){
processQueue[head] = null;
head++;
length--;

}
 
public void leave(int index,boolean isReleased){
//决定是否释放内存
if(isReleased){
releaseMemory(index);
}
processQueue[index] = null;
for(int i = index + 1;i <= rear;i++){
processQueue[i - 1] = processQueue[i];
}
if(rear >= 0){
processQueue[rear] = null;
}
rear--;
length--;

}

//选取可以进入其它队列的进程
public int select(){
//选择排序
PCB smallest = this.processQueue[0];
int smallestIndex = 0;
for(int i = 1;i <= rear;i++){
//选取最小项
if(this.processQueue[i].priority < smallest.priority){
smallest = this.processQueue[i];
smallestIndex = i;
}
}
return smallestIndex;
}

public void clear(){
processQueue = new PCB[100];
head = 0;
rear = -1;
length = 0;
allocatePid = 0;
capacity = 15;
}

public void releaseMemory(int index){
PCB p1 = processQueue[index];
mf.used = mf.used - p1.needMemory;
mf.remain = mf.remain + p1.needMemory;
for(int i = p1.beginMemory;i < p1.beginMemory + p1.needMemory;i++){
mf.memory[i] = 0;
}
}

//检查从begin开始的内存单元是否符合要求
public boolean check(int begin,int need){
for(int i = begin;i < begin + need;i++){
if(mf.memory[i] == 1){
return false;
}
}
return true;
}

public void running(){
//减少时间
for(int i = head; i<= rear;i++){
processQueue[i].time--;
}
for(int i = head; i<= rear;i++){
if(processQueue[i].time <= 0){
mf.event.append("进程" + processQueue[i].processName + "运行完毕，已退出队列,内存已回收\n");
leave(i,true);
}
}
}

}