操作系统实验进程调度和内存管理java语言版本

第一个类：divDTO

publicclassdivDTO

{

privateintdivBase;

privateintlength;

privateintdivFlag;

publicdivDTO(intdivBase,intlength,intdivFlag)

{

this.divBase=divBase;

this.divFlag=divFlag;

this.length=length;

}

publicdivDTO()

{

}

publicvoidsetDivBase(intbase)

{

this.divBase=base;

}

publicintgetDivBase()

{

returnthis.divBase;

}

publicvoidsetLength(intlength)

{

this.length=length;

}

publicintgetLength()

{

returnthis.length;

}

publicvoidsetDivFlag(intflag)

{

this.divFlag=flag;

}

publicintgetDivFalg()

{

returnthis.divFlag;

}

}

2.第二个类：PcbDTO

publicclassPcbDTO

{

staticfinalintRunning=1;

staticfinalintReady=2;

staticfinalintWaiting=3;

privateStringprocessName;

privateintrunTime;

privateintprority;

privateintprocessState;

privateintbase;

privateintlimit;

privateintpcbFlag;

publicPcbDTO(Stringname,inttime,intpro,intbase,intlimit)

{

this.processName=name;

this.runTime=time;

this.prority=pro;

this.processState=0;

this.limit=limit;

this.base=base;

}

publicPcbDTO()

{this.pcbFlag=0;}

publicvoidsetProcessName(Stringname)

{

this.processName=name;

}

publicStringgetProcessName()

{

returnprocessName;

}

publicvoidsetRunTime(inttime)

{

this.runTime=time;

}

publicintgetRunTime()

{

returnthis.runTime;

}

publicvoidsetPrority(intprority)

{

this.prority=prority;

}

publicintgetPrority()

{

returnthis.prority;

}

publicvoidsetProcessState(intstate)

{

this.processState=state;

}

publicStringgetProcessState()

{

Strings=newString();

if(this.processState==1)

{

s=\"running\";

}

elseif(this.processState==2)

{

s=\"ready\";

}

elseif(this.processState==3)

{

s=\"waiting\";

}

returns;

}

publicintgetBase()

{

returnthis.base;

}

publicvoidsetBase(intbase)

{

this.base=base;

}

publicvoidsetLimit(intlimit)

{

this.limit=limit;

}

publicintgetLimit()

{

returnthis.limit;

}

}

第三个类：主类

importjavax.swing.*;

importjava.util.*;

importjava.awt.*;

publicclassMainFrame

{

privateJListreadyList;

privateJListwaitingList;

privateJListjobList;

privateJButtonsusButton;

privateJButtonrelaxButton;

privateJButtonstartButton;

privateJButtonnewButton;

privateJLabelnameLabel;

privateJLabelprorityLabel;

privateJLabeltimeLabel;

privateJLabeljobLabel;

privateJLabelreadyLabel;

privateJLabelwaitingLabel;

privateJLabelrunningLabel;

privateJLabelspaceLabel;

privateJLabeldivLabel;

privateJLabelallocLabel;

privateJTablereadyTable;

privateJTablerunningTable;

privateJTabledivTable;

privateJTableallocTable;

privateJTextFieldnameText;

privateJTextFieldtimeText;

privateJTextFieldspaceText;

privateJComboBoxprorityCom;

privateJPanelnewPanel;

privateJPanelwaitingPanel;

privateJPanelreadyPanel;

VectorjobVectorName;

VectorjobDtoVector;

VectorwaitingVectorName;

VectorwaitingDtoVector;

PcbDTO[]readyDtoArray;

PcbDTO[]newDtoArray;

divDTO[]divDtoArray;

PcbDTO[]newSort;

Object[][]readydata;

Object[][]runningdata;

Object[][]divdata;

Object[][]allocdata;

intfirst;

intend;

intpoint;

PcbDTOa;

publicMainFrame()

{

a=newPcbDTO();

first=0;

end=0;

point=0;

JFramejf=newJFrame(\"进程调度-ws\");

Containerc=jf.getContentPane();

c.setLayout(null);

//c.setBackground(Color.pink);

newPanel=newJPanel();

newPanel.setLayout(null);

waitingPanel=newJPanel();

waitingPanel.setLayout(null);

//waitingPanel.setBackground(Color.pink);

readyPanel=newJPanel();

readyPanel.setLayout(null);

susButton=newJButton(\"挂起\");

relaxButton=newJButton(\"释放\");

startButton=newJButton(\"开始\");

newButton=newJButton(\"新建进程\");

nameLabel=newJLabel(\"进程名\");

prorityLabel=newJLabel(\"优先级\");

timeLabel=newJLabel(\"运行时间\");

jobLabel=newJLabel(\"后备队列\");

readyLabel=newJLabel(\"就绪队列\");

waitingLabel=newJLabel(\"等待队列\");

runningLabel=newJLabel(\"运行进程\");

spaceLabel=newJLabel(\"需要空间\");

divLabel=newJLabel(\"未分分区表\");

allocLabel=newJLabel(\"内存分配表\");

nameText=newJTextField();

timeText=newJTextField();

spaceText=newJTextField();

prorityCom=newJComboBox();

prorityCom.setToolTipText(\"优先级\");

readyDtoArray=newPcbDTO[6];

newSort=newPcbDTO[6];

for(inti=0;i<6;i++)

{

newSort[i]=newPcbDTO();

}

newDtoArray=newPcbDTO[100];

jobDtoVector=newVector();

jobVectorName=newVector();

waitingDtoVector=newVector();

waitingVectorName=newVector();

divDtoArray=newdivDTO[20];

for(inti=0;i<20;i++)

{

divDtoArray[i]=newdivDTO();

divDtoArray[i].setDivFlag(0);

}

divDtoArray[0].setDivFlag(1);

divDtoArray[0].setDivBase(20);

divDtoArray[0].setLength(180);

readydata=newObject[6][4];

runningdata=newObject[2][3];

divdata=newObject[20][3];

allocdata=newObject[20][3];

String[]col1={\"进程\时间\优先级\状态\

String[]col2={\"进程\时间\优先级\

String[]col3={\"起址\长度\状态\

String[]col4={\"起址\长度\占用进程\

readyTable=newJTable(readydata,col1);

//readyTable.setEnabled(false);

runningTable=newJTable(runningdata,col2);

runningTable.setRowHeight(22);

runningTable.setEnabled(false);

allocTable=newJTable(allocdata,col4);

allocTable.setEnabled(false);

divTable=newJTable(divdata,col3);

divTable.setEnabled(false);

divTable.setValueAt(String.valueOf(20),0,0);

divTable.setValueAt(String.valueOf(180),0,1);

divTable.setValueAt(String.valueOf(1),0,2);

JScrollPanerunningSP=newJScrollPane();

JScrollPanereadySP2=newJScrollPane();

JScrollPanedivSP=newJScrollPane();

JScrollPaneallocSP=newJScrollPane();

runningSP.getViewport().add(runningTable);

readySP2.getViewport().add(readyTable);

divSP.getViewport().add(divTable);

allocSP.getViewport().add(allocTable);

//int[]prorityArray=newint[10];

for(inti=0;i<10;i++)

{

prorityCom.addItem(i);//prorityArray[i]=i;

}

jobList=newJList();

waitingList=newJList();

JScrollPanereadySP=newJScrollPane(readyList);

JScrollPanejobSP=newJScrollPane(jobList);

JScrollPanewaitingSP=newJScrollPane(waitingList);

newPanel.setSize(450,100);

newPanel.setLocation(0,0);

nameLabel.setSize(80,20);

nameLabel.setLocation(10,5);

nameText.setSize(100,25);

nameText.setLocation(10,30);

prorityLabel.setSize(80,20);

prorityLabel.setLocation(120,5);

prorityCom.setSize(100,25);

prorityCom.setLocation(120,30);

timeLabel.setSize(80,20);

timeLabel.setLocation(230,5);

timeText.setSize(100,25);

timeText.setLocation(230,30);

spaceLabel.setSize(80,20);

spaceLabel.setLocation(340,5);

spaceText.setSize(100,25);

spaceText.setLocation(340,30);

newButton.setSize(100,20);

newButton.setLocation(320,70);

waitingPanel.setSize(190,410);

waitingPanel.setLocation(0,100);

jobLabel.setSize(100,20);

jobLabel.setLocation(10,2);

jobSP.setSize(180,105);

jobSP.setLocation(10,25);

waitingLabel.setSize(100,20);

waitingLabel.setLocation(10,129);

waitingSP.setSize(180,105);

waitingSP.setLocation(10,150);

divLabel.setSize(100,20);

divLabel.setLocation(10,253);

divSP.setSize(180,113);

divSP.setLocation(10,273);

relaxButton.setSize(80,20);

relaxButton.setLocation(110,388);

readyPanel.setSize(260,410);

readyPanel.setLocation(190,100);

readyLabel.setSize(100,22);

readyLabel.setLocation(10,2);

allocLabel.setSize(100,20);

allocLabel.setLocation(10,232);

startButton.setSize(80,20);

startButton.setLocation(177,388);

susButton.setSize(80,20);

susButton.setLocation(95,388);

readySP2.setSize(250,117);

readySP2.setLocation(10,25);

runningLabel.setLocation(10,142);

runningLabel.setSize(100,20);

runningSP.setSize(250,65);

runningSP.setLocation(10,167);

allocSP.setSize(250,130);

allocSP.setLocation(10,255);

c.add(newPanel);

newPanel.add(nameLabel);

newPanel.add(nameText);

newPanel.add(prorityLabel);

newPanel.add(prorityCom);

newPanel.add(timeText);

newPanel.add(timeLabel);

newPanel.add(newButton);

newPanel.add(spaceLabel);

newPanel.add(spaceText);

c.add(waitingPanel);

waitingPanel.add(jobLabel);

waitingPanel.add(jobSP);

waitingPanel.add(waitingLabel);

waitingPanel.add(waitingSP);

waitingPanel.add(divLabel);

waitingPanel.add(divSP);

waitingPanel.add(relaxButton);

c.add(readyPanel);

readyPanel.add(readyLabel);

readyPanel.add(allocLabel);

readyPanel.add(runningLabel);

readyPanel.add(startButton);

readyPanel.add(susButton);

readyPanel.add(allocSP);

readyPanel.add(runningSP);

readyPanel.add(readySP2);

jf.setSize(470,550);

jf.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

jf.setLocationRelativeTo(null);

jf.setVisible(true);

startButton.addActionListener(newMyActionListener());

newButton.addActionListener(newMyActionListener());

susButton.addActionListener(newMyActionListener());

relaxButton.addActionListener(newMyActionListener());

}

publicvoidsus()

{

try

{

Thread.sleep(1000);

}

catch(Exceptionex)

{

}

}

classMyActionListenerimplementsActionListener

{

publicvoidactionPerformed(ActionEvente)

{

intcount=0;

PcbDTOtest=newPcbDTO();

JButtonjb=(JButton)e.getSource();

intmax=-1;

if(jb==startButton)

{

//while(true)

//{

intrunAllocFlag=-1;

if((String)runningTable.getValueAt(0,0)==null||(String)runningTable.getVal

ueAt(0,0)==\"\")

{

try

{

Thread.sleep(0);

}

catch(Exceptionex)

{

}

到3\");

for(intj=first;j!=end;)

{

if(!readyDtoArray[j].getProcessState().equals(\"waiting\"))

{

max=j;

break;

}

j=(j+1)%6;

}

for(intj=first;j%6!=end;)

{

if(!readyDtoArray[j].getProcessState().equals(\"waiting\"))

{

if(readyDtoArray[j].getPrority()>readyDtoArray[max].getPrority())

{

max=j;

}

}

j=(j+1)%6;

}

if(max>=0)

{

a=readyDtoArray[max];

readyDtoArray[max]=readyDtoArray[first];

readyDtoArray[first]=a;

readyTable.setValueAt(readyDtoArray[max].getProcessName(),max,0);

readyTable.setValueAt(readyDtoArray[max].getRunTime(),max,1);

readyTable.setValueAt(readyDtoArray[max].getPrority(),max,2);

readyTable.setValueAt(readyDtoArray[max].getProcessState(),max,3);

readyTable.setValueAt(\"\

readyTable.setValueAt(\"\

readyTable.setValueAt(\"\

readyTable.setValueAt(\"\

runningTable.setValueAt(a.getProcessName(),0,0);

runningTable.setValueAt(a.getRunTime(),0,1);

runningTable.setValueAt(a.getPrority(),0,2);

readyDtoArray[first].setRunTime(readyDtoArray[first].getRunTime()-1);

if(0!=readyDtoArray[first].getPrority())

{

readyDtoArray[first].setPrority(readyDtoArray[first].getPrority()-1);

}

first=(first+1)%6;

}

else

{

等待中……\");

}

中

}

else

{

/*try

{

Thread.sleep(2000);

}

catch(InterruptedExceptione1)

{

}*/

到1\");

runningTable.setValueAt(\"\

runningTable.setValueAt(\"\

runningTable.setValueAt(\"\

//如果运行时间为0则撤销进程，否则将进程重新添加到就绪队列

if(a.getRunTime()<=0)

{

//收回内存空间

for(inti=0;i{

if(newSort[i].getBase()>=a.getBase())

{

newSort[i]=newSort[i+1];

}

}

point--;

//设置内存分配表的内容

for(inti=0;i{

allocTable.setValueAt(String.valueOf(newSort[i].getBase()),i,0);

allocTable.setValueAt(String.valueOf(newSort[i].getLimit()),i,1);

allocTable.setValueAt(newSort[i].getProcessName(),i,2);

}

allocTable.setValueAt(\"\

allocTable.setValueAt(\"\

allocTable.setValueAt(\"\

//把收回的内存加入到记录未分分区的数组

intmemoryEnd=0;

intlocation=0;

intup=-1;//

intdown=-1;

for(inti=0;i<20;i++)

{

if(divDtoArray[i].getDivFalg()==1)

{

memoryEnd=divDtoArray[i].getDivBase()+divDtoArray[i].getLength();

if(memoryEnd==a.getBase())

{

up=i;

}

if(divDtoArray[i].getDivBase()==(a.getBase()+a.getLimit()))

{

down=i;

}

}

}

if(up>=0&&down>=0)

{

divDtoArray[up].setLength((divDtoArray[up].getLength()+a.getLimit()+divDto

Array[down].getLength()));

divDtoArray[down].setDivFlag(0);

for(inti=(down+1);i<20;i++)

{

if(divDtoArray[i].getDivFalg()==1)

{

divDtoArray[i-1].setDivBase(divDtoArray[i].getDivBase());

divDtoArray[i-1].setDivFlag(1);

divDtoArray[i-1].setLength(divDtoArray[i].getLength());

divDtoArray[i].setDivFlag(0);

}

else

{

divTable.setValueAt(\"\

divTable.setValueAt(\"\

divTable.setValueAt(\"\

break;

}

}

}

elseif(up>=0&&down<0)

{

divDtoArray[up].setLength((divDtoArray[up].getLength()+a.getLimit()));

}

elseif(up<0&&down>=0)

{

divDtoArray[down].setLength((divDtoArray[down].getLength()+a.getLimit()));

divDtoArray[down].setDivBase(a.getBase());

}

elseif(up<0&&down<0)

{

for(inti=0;i<20;i++)

{

)

if(divDtoArray[i].getDivBase()>a.getBase()||divDtoArray[i].getDivFalg()==0

{

location=i;

break;

}

}

for(inti=20;i>location;i--)

{

if(divDtoArray[i-1].getDivFalg()==1)

{

divDtoArray[i].setDivBase(divDtoArray[i-1].getDivBase());

divDtoArray[i].setDivFlag(1);

divDtoArray[i].setLength(divDtoArray[i-1].getLength());

}

}

divDtoArray[location].setDivBase(a.getBase());

divDtoArray[location].setDivFlag(1);

divDtoArray[location].setLength(a.getLimit());

}

//设置未分分区表的内容

for(inti=0;i<20;i++)

{

if(divDtoArray[i].getDivFalg()==1)

{

divTable.setValueAt(String.valueOf(divDtoArray[i].getDivBase()),i,0);

divTable.setValueAt(String.valueOf(divDtoArray[i].getLength()),i,1);

divTable.setValueAt(String.valueOf(divDtoArray[i].getDivFalg()),i,2);

}

}

if(!jobDtoVector.isEmpty())

{

intrunLength=0;

PcbDTOjobToReady=(PcbDTO)jobDtoVector.elementAt(0);

for(inti=0;i<20;i++)

{

if(divDtoArray[i].getDivFalg()==1)

{

if(divDtoArray[i].getLength()>=jobToReady.getLimit())

{

runAllocFlag=i;

break;

}

}

}

if(runAllocFlag>=0)

{

jobDtoVector.removeElementAt(0);

jobVectorName.remove(jobVectorName.indexOf(jobToReady.getProcessName()));

jobList.setListData(jobVectorName);

jobToReady.setProcessState(PcbDTO.Ready);

jobToReady.setBase(divDtoArray[runAllocFlag].getDivBase());

runLength=divDtoArray[runAllocFlag].getLength()-jobToReady.getLimit();

if(runLength==0)

{

inti=runAllocFlag;

divDtoArray[i].setDivFlag(0);

for(;i<19;i++)

{

if(divDtoArray[i+1].getDivFalg()==1)

{

divDtoArray[i]=divDtoArray[i+1];

divDtoArray[i+1].setDivFlag(0);

}

divTable.setValueAt(String.valueOf(divDtoArray[i].getDivBase()),i,0);

divTable.setValueAt(String.valueOf(divDtoArray[i].getLength()),i,1);

divTable.setValueAt(String.valueOf(divDtoArray[i].getDivFalg()),i,2);

}

divTable.setValueAt(String.valueOf(divDtoArray[i].getDivFalg()),i,2);

}

elseif(runLength>0)

{

intc2=divDtoArray[runAllocFlag].getDivBase()+jobToReady.getLimit();

divDtoArray[runAllocFlag].setDivBase(c2);

divDtoArray[runAllocFlag].setLength(runLength);

divTable.setValueAt(String.valueOf(c2),runAllocFlag,0);

divTable.setValueAt(String.valueOf(runLength),runAllocFlag,1);

divTable.setValueAt(String.valueOf(divDtoArray[runAllocFlag].getDivFalg())

,runAllocFlag,2);

}

readyDtoArray[end]=jobToReady;

readyTable.setValueAt(jobToReady.getProcessName(),end,0);

readyTable.setValueAt(jobToReady.getRunTime(),end,1);

readyTable.setValueAt(jobToReady.getPrority(),end,2);

readyTable.setValueAt(jobToReady.getProcessState(),end,3);

end=(end+1)%6;

intruni=0;//用于记录当前新生成的PcbDTO对象应该

插入到newSort中的位置

for(;runi{

if(jobToReady.getBase(){

break;

}

}

//如果不是插入到数组末尾，则把比它大的都向后挪

一位并设置JTable中的显示

for(inti=point;i>runi;i--)

{

newSort[i]=newSort[i-1];

allocTable.setValueAt(String.valueOf(newSort[i].getBase()),i,0);

allocTable.setValueAt(String.valueOf(newSort[i].getLimit()),i,1);

allocTable.setValueAt(newSort[i].getProcessName(),i,2);

}

//插入新生成的对象

newSort[runi]=jobToReady;

allocTable.setValueAt(String.valueOf(jobToReady.getBase()),runi,0);

allocTable.setValueAt(String.valueOf(jobToReady.getLimit()),runi,1);

allocTable.setValueAt(jobToReady.getProcessName(),runi,2);

point++;

}

}

}

else

{

readyDtoArray[end]=a;

readyTable.setValueAt(a.getProcessName(),end,0);

readyTable.setValueAt(a.getRunTime(),end,1);

readyTable.setValueAt(a.getPrority(),end,2);

readyTable.setValueAt(a.getProcessState(),end,3);

end=(end+1)%6;

}

}

//}

}

elseif(jb==newButton)

{

intnewAllocFlag=-1;

intnewLength=0;

if(nameText.getText().trim().length()==0)

{

JOptionPane.showMessageDialog(null,\"进程名不能为空！\");

}

elseif(timeText.getText().trim().length()==0)

{

JOptionPane.showMessageDialog(null,\"运行时间不能为空\");

}

elseif(spaceText.getText().trim().length()==0)

{

JOptionPane.showMessageDialog(null,\"空间不能为空\");

}

else

{

test.setRunTime(Integer.parseInt(timeText.getText()));

test.setLimit(Integer.parseInt(spaceText.getText()));

Strings=prorityCom.getSelectedItem().toString();

test.setPrority(Integer.parseInt(s));

test.setProcessName(nameText.getText().trim());

newDtoArray[count]=test;

jobDtoVector.add(newDtoArray[count]);

jobVectorName.add(newDtoArray[count].getProcessName());

jobList.setListData(jobVectorName);

count++;

nameText.setText(\"\");

timeText.setText(\"\");

spaceText.setText(\"\");

PcbDTOb=(PcbDTO)jobDtoVector.elementAt(0);

for(inti=0;i<20;i++)

{

if(divDtoArray[i].getDivFalg()==1)

{

if(divDtoArray[i].getLength()>=b.getLimit())

{

newAllocFlag=i;

break;

}

}

}

//在就绪队列未满且内存有足够空间时将后备队列jobDtoVetor中的

对象添加到就绪队列中

if((end+2)%6!=first&&newAllocFlag>=0)

{

jobDtoVector.removeElementAt(0);

b.setProcessState(PcbDTO.Ready);

b.setBase(divDtoArray[newAllocFlag].getDivBase());

newLength=divDtoArray[newAllocFlag].getLength()-b.getLimit();

if(newLength==0)

{

inti=newAllocFlag;

divDtoArray[i].setDivFlag(0);

for(;i<19;i++)

{

if(divDtoArray[i+1].getDivFalg()==1)

{

divDtoArray[i]=divDtoArray[i+1];

divDtoArray[i+1].setDivFlag(0);

}

divTable.setValueAt(String.valueOf(divDtoArray[i].getDivBase()),i,0);

divTable.setValueAt(String.valueOf(divDtoArray[i].getLength()),i,1);

divTable.setValueAt(String.valueOf(divDtoArray[i].getDivFalg()),i,2);

}

divTable.setValueAt(String.valueOf(divDtoArray[i].getDivFalg()),i,2);

}

elseif(newLength>0)

{

intc1=divDtoArray[newAllocFlag].getDivBase()+b.getLimit();

divDtoArray[newAllocFlag].setDivBase(c1);

divDtoArray[newAllocFlag].setLength(newLength);

divTable.setValueAt(String.valueOf(c1),newAllocFlag,0);

divTable.setValueAt(String.valueOf(newLength),newAllocFlag,1);

divTable.setValueAt(String.valueOf(divDtoArray[newAllocFlag].getDivFalg())

,newAllocFlag,2);

}

readyDtoArray[end]=b;

jobVectorName.remove(jobVectorName.indexOf(b.getProcessName()));

readyTable.setValueAt(b.getProcessName(),end,0);

readyTable.setValueAt(b.getRunTime(),end,1);

readyTable.setValueAt(b.getPrority(),end,2);

newSort中的位置

JTable中的显示

readyTable.setValueAt(\"ready\

end=(end+1)%6;

intnewi=0;//用于记录当前新生成的PcbDTO对象应该插入到

for(;newi{

if(b.getBase(){

break;

}

}

//如果不是插入到数组末尾，则把比它大的都向后挪一位并设置

for(inti=point;i>newi;i--)

{

newSort[i]=newSort[i-1];

allocTable.setValueAt(String.valueOf(newSort[i].getBase()),i,0);

allocTable.setValueAt(String.valueOf(newSort[i].getLimit()),i,1);

allocTable.setValueAt(newSort[i].getProcessName(),i,2);

}

//插入新生成的对象

newSort[newi]=b;

allocTable.setValueAt(String.valueOf(b.getBase()),newi,0);

allocTable.setValueAt(String.valueOf(b.getLimit()),newi,1);

allocTable.setValueAt(b.getProcessName(),newi,2);

point++;

}

}

}

elseif(jb==susButton)

{

if(readyDtoArray[readyTable.getSelectedRow()]!=null)

{

if(!readyDtoArray[readyTable.getSelectedRow()].getProcessState().equals(\"w

aiting\"))

{

;

readyDtoArray[readyTable.getSelectedRow()].setProcessState(PcbDTO.Waiting)

readyTable.setValueAt(\"waiting\

waitingDtoVector.add(readyDtoArray[readyTable.getSelectedRow()]);

waitingVectorName.add(readyDtoArray[readyTable.getSelectedRow()].getProces

sName());

waitingList.setListData(waitingVectorName);

}

else

{

已挂起\");

}

}

else

{

JOptionPane.showMessageDialog(null,\"请选择要挂起的进程\");

请选择要挂起的进程\");

}

}

elseif(jb==relaxButton)

{

Strings=(String)waitingList.getSelectedValue();

if(s!=null)

{

waitingVectorName.remove(s);

PcbDTOp=newPcbDTO();

for(inti=0;i{

p=(PcbDTO)waitingDtoVector.elementAt(i);

if(s.equals(p.getProcessName()))

{

p.setProcessState(PcbDTO.Ready);

waitingDtoVector.remove(p);

break;

}

}

for(inti=0;i<6;i++)

{

if(s.equals(readyDtoArray[i].getProcessName()))

{

readyTable.setValueAt(\"ready\

break;

}

}

waitingList.setListData(waitingVectorName);

}

else

{

JOptionPane.showMessageDialog(null,\"请选择要解挂的进程\");

没有选择的进程\");

}

}

}

}

publicstaticvoidmain(Stringargs[])

{

newMainFrame();

}

}

相关截图如下：

运行后开始界面输入进程后界面

建立后挂起挂起后各内存分配

解挂

操作异常时的提示