processctrl.java

操作系统进程调度算法java实现

package os;
import java.util.*;

import javax.swing.JTable;
public class ProcessCtrl {
	int policy;//进程调度策略  1代表先来先  2代表短作业优先 3代表高优级优先静态 4代表分时 5代表分时+高优先级优先动态
    LinkedList WaitQueue=new LinkedList();//等待队列
   LinkedList RunQueue=new LinkedList();//运行队列
    LinkedList WaitRunQueue=new LinkedList();//就绪队列
    LinkedList CompleteQueue=new LinkedList();//完成队列
   int ConsultTime;//程序消耗时间
   int ProcessID=1000;//进程ID
   int priority;//优先权
   int counter;//时间片
   /** Creates a new instance of ProcessCtrl */
   public ProcessCtrl() {
      
   }
   /**
    *创建一个新的进程
    */
    JTable createAProcess(int priority,int ConsultTime){
     
       this.priority=priority;
       this.ConsultTime=ConsultTime;
       this.counter=priority;
       this.ProcessID=createID();//生成ID
       Vector PCB=new Vector(4);//进程控制块 0对应进程ID 1对应进程优先级 2对应进程时间片 3对应进程消耗时间
        PCB.add(new Integer(ProcessID));
        PCB.add(new Integer(priority));
        PCB.add(new Integer(counter));
        PCB.add(new Integer(ConsultTime));
       //入就绪队列
       WaitRunQueue.add(PCB);
       //Vector v=(Vector)WaitRunQueue.getFirst();
       //Integer k=(Integer)v.get(0);
       //int m=k.intValue();
       //System.out.println(m);
      
       String [] headings=new String[]{"ID","优先级","时间片","消耗时间"};
       Object[][]data=new Object[WaitRunQueue.size()][4];
       for(int i=0;i<WaitRunQueue.size();i++){
        Vector v=(Vector)WaitRunQueue.get(i);
        
        data[i][0]=(Integer)v.get(0);
        data[i][1]=(Integer)v.get(1);
        data[i][2]=(Integer)v.get(2);
        data[i][3]=(Integer)v.get(3);
       }
        
       JTable table=new JTable(data,headings);
       return table;//返回填充过信息的表
     
   }
   
   
    JTable createAProcess(int ProcessID,int priority,int ConsultTime){
     
       this.priority=priority;
       this.ConsultTime=ConsultTime;
       this.counter=priority;
       this.ProcessID=ProcessID;//生成ID
       Vector PCB=new Vector(4);//进程控制块 0对应进程ID 1对应进程优先级 2对应进程时间片 3对应进程消耗时间
        PCB.add(new Integer(ProcessID));
        PCB.add(new Integer(priority));
        PCB.add(new Integer(counter));
        PCB.add(new Integer(ConsultTime));
       //入就绪队列
       WaitRunQueue.add(PCB);
       //Vector v=(Vector)WaitRunQueue.getFirst();
       //Integer k=(Integer)v.get(0);
       //int m=k.intValue();
       //System.out.println(m);
      
       String [] headings=new String[]{"ID","优先级","时间片","消耗时间"};
       Object[][]data=new Object[WaitRunQueue.size()][4];
       for(int i=0;i<WaitRunQueue.size();i++){
        Vector v=(Vector)WaitRunQueue.get(i);
        
        data[i][0]=(Integer)v.get(0);
        data[i][1]=(Integer)v.get(1);
        data[i][2]=(Integer)v.get(2);
        data[i][3]=(Integer)v.get(3);
       }
        
       JTable table=new JTable(data,headings);
       return table;//返回填充过信息的表
     
   }
   
   
    static int id=1000;
     static int createID(){//生成ID
     id=id+5;
     return id;
     
    }
    
    
     void goTOWaitQueue(Vector v){//入等待队列
      WaitQueue.add(v);

      
     }
    
     void WaitToRun(){//等待队列全部入就绪队列
      for(int i=0;i<WaitQueue.size();i++){
       WaitRunQueue.add((Vector)WaitQueue.remove(i));
      }
      
 
     }
    
     JTable getWaitRun(){//得到WaitRun队列视图
       String [] headings=new String[]{"ID","优先级","时间片","消耗时间"};
       Object[][]data=new Object[WaitRunQueue.size()][4];
      
       for(int i=0;i<WaitRunQueue.size();i++){

        Vector vv=(Vector)WaitRunQueue.get(i);
        
        data[i][0]=(Integer)vv.get(0);
        data[i][1]=(Integer)vv.get(1);
        data[i][2]=(Integer)vv.get(2);
        data[i][3]=(Integer)vv.get(3);
       }
        
       JTable table=new JTable(data,headings);
       return table;//返回填充过信息的表
     }
    
    
     JTable getWait(){//得到Wait队列视图
      String [] headings=new String[]{"ID","优先级","时间片","消耗时间"};
       Object[][]data=new Object[WaitQueue.size()][4];
       for(int i=0;i<WaitQueue.size();i++){
        Vector vv=(Vector)WaitQueue.get(i);
        
        data[i][0]=(Integer)vv.get(0);
        data[i][1]=(Integer)vv.get(1);
        data[i][2]=(Integer)vv.get(2);
        data[i][3]=(Integer)vv.get(3);
       }
        
       JTable table=new JTable(data,headings);
       return table;//返回填充过信息的表
      
     }
    
     JTable getComplete(){//得到Complete队列视图
      String [] headings=new String[]{"ID","优先级","时间片","消耗时间"};
       Object[][]data=new Object[CompleteQueue.size()][4];
       for(int i=0;i<CompleteQueue.size();i++){
        Vector vv=(Vector)CompleteQueue.get(i);
        
        data[i][0]=(Integer)vv.get(0);
        data[i][1]=(Integer)vv.get(1);
        data[i][2]=(Integer)vv.get(2);
        data[i][3]=(Integer)vv.get(3);
       }
        
       JTable table=new JTable(data,headings);
       return table;//返回填充过信息的表
      
     }
    
    
    
    
    Vector schedule(int policy){
     this.policy=policy;
     Vector v=new Vector();
     switch(policy){
     case 1: v=FirstDo();break;
     case 2:v=ShortWork();break;
     case 3:v=StaticPriority();break;
     case 4:v=DivideTime();break;
     //case 5:DivideAndDynamicPriority();break;

     }
     return v;  
    }
    boolean can=true;//返回是否还能再运行，队列为空停止运行
    boolean ifCanSchedule(){
     if(WaitRunQueue.size()>0) can=true;
     else can=false;
     return can;
    }
   
   
    Vector FirstDo(){
     Vector v=(Vector)WaitRunQueue.removeFirst();
     
   
     return v;
      
    }
   
   
   
    Vector ShortWork(){
     Integer temp1=new Integer("1000");
     int k=0;
     for(int i=0;i<WaitRunQueue.size();i++)
     {
      
      Vector v=(Vector)WaitRunQueue.get(i);
      Integer gg=(Integer)v.get(3);
      if(gg.compareTo(temp1)<0) {temp1=gg; k=i;}
      
     }
     
     return (Vector)WaitRunQueue.remove(k);
       
    }
   
   
    Vector StaticPriority(){
     Integer temp1=new Integer("0");
     int k=0;
     for(int i=0;i<WaitRunQueue.size();i++)
     {
      
      Vector v=(Vector)WaitRunQueue.get(i);
      Integer gg=(Integer)v.get(1);
      if(gg.compareTo(temp1)>0) {temp1=gg; k=i;}
      
     }
     
     return (Vector)WaitRunQueue.remove(k);
       
    }
   
    int DivideTemp=0;
    Vector DivideTime(){

      
      Vector v=(Vector)WaitRunQueue.getFirst();
      Integer ConsultTime=(Integer)v.get(3);
      Integer counter=(Integer)v.get(2);
      if(counter.compareTo(ConsultTime)>=0)
      {
       v.add(2,new Integer(0));
       v.add(3,new Integer(0));
       DivideTemp=1;
       return (Vector)WaitRunQueue.removeFirst();
       
      }
      
      
      else
      {
       
       int k=ConsultTime.intValue();
       int x=counter.intValue();
       v.add(3,new Integer(k-x));
       WaitRunQueue.add(v);
       DivideTemp=0;
       return (Vector)WaitRunQueue.removeFirst();
      }
     
    }
}