processcall.java

操作系统中的进程调度

import java.util.*;
import java.io.*;

//进程类，可以产生进程对象
class Process{
   private String  name;
   private int     state;     //0 表示就绪 1等待
   private int     sort;      //优先级，sort越大优先级越高,随机产生（1-5）
   private int     time;      //执行时间
   private Random rd=new Random();      //用于产生随机数

   Process (String in_name){
         name=in_name;
         time=rd.nextInt(20)+1;         //随机产生0到19的整数
         sort=rd.nextInt(5)+1;
   }
   int Begin_state(){

      state=rd.nextInt(2);          //返回随机产生的0或1，用于判断处于就绪还是等待队列
      return state;
   }
   String getName(){
     return name; 
   }
   int getTime(){
     return time;
   }
   void setTime(int inputtime){
      time=inputtime;
   }
   int getSort(){
      return sort;
   }
   void print(){
      System.out.println("进程名 "+name+"  "+"执行所需时间"+time+"ms"+"\t\t"+"进程状态: "+state+"  "+"优先数  "+sort);
   }

}
//主类
public class ProcessCall{
   //主函数，调用各种不同算法函数
   public static void main(String []args)throws IOException{
       LinkedList<Process> ready=new LinkedList<Process>();          //就绪队列链表头
       LinkedList<Process> wait =new LinkedList<Process>();          //等待队列链表头

       BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
       boolean in=true;
       String s=new String();
      
       String []name={"a","b","c","d","e","f","g","h","i","j"};  //进程名

       while(in){
          for(int i=0;i<10;i++){
             Process process=new Process(name[i]);        //产生一个进程
             if (process.Begin_state()==0){
                   ready.addLast(process);
             }
             else{ 
                   wait.addLast(process);
             }     
          }
       
          System.out.println("\n选择调度算法"+"\n\n"+"1-先进先出调度算法  2-基于优先数的调度算法  3-最短执行时间调度算法  其他数字键键-退出");

          try{
             s=br.readLine();          //接受Ascii码，1的Ascii码为49；
          }catch(IOException e){};

          switch(Integer.parseInt(s)){
             case 1: call_FCFS(ready,wait);in=true;break;      //调用先进先出算法
             case 2: call_PrevSort(ready,wait);in=true;break;      //调用基于优先数的调度算法
             case 3: call_LessTime(ready,wait);in=true;break;   //调用最短执行时间调度算法
             default: in=false;System.out.println("退出系统！");
          }
       }                  
  }
//输出链表内容
  static void outPrint(LinkedList<Process> list){
       Process temp;         
       if(list.size()>0){
          for(int i=0;i<list.size();i++){
              temp=list.get(i);
              System.out.print("第"+(i+1)+"个进程："+"\t");
              temp.print();
          }
       }
       else  
          System.out.println("空队列");
  }
//输出所有进程信息
  static void process_Print(LinkedList<Process> ready,LinkedList<Process> wait){
      System.out.println("\n就绪队列:");
      outPrint(ready);
      System.out.println("等待队列:");
      outPrint(wait);
  }

//先进先出调度算法函数
  static void call_FCFS(LinkedList<Process> ready,LinkedList<Process> wait){
      int time=0;        //处理机分配的时间片
      Random rd=new Random();
     
      //执行进程
      while(ready.size()>0 || wait.size()>0){
          process_Print(ready,wait);      //输出所有进程信息
          time=rd.nextInt(15)+5;   //随机产生时间片长度
          System.out.println("\n时间片长度： "+time);
          
          if(ready.size()>0){
             
             if(ready.get(0).getTime() > time){              //进程执行所需时间大于处理机分配的时间片，执行完时间片长度后
                 ready.get(0).setTime(ready.get(0).getTime()-time);   //该进程随机进入等待或就绪对列，否则该进程执行完毕删除
                 if(rd.nextInt(2)==0){                                 //该进程
                     ready.add(ready.get(0));
                     System.out.print("进程："+ready.get(0).getName()+" 时间片不够进入就绪对列队尾。  ");
                 }
                  else{
                     wait.add(ready.get(0));
                     System.out.print("进程："+ready.get(0).getName()+" 时间片不够进入等待对列队尾。  ");
                  }
             }
             else 
                System.out.print("进程："+ready.get(0).getName()+" 执行完毕！ ");

             ready.remove(0); 
          }
          //在进程执行过程中，产生随机数0或1，该随机数为1时，将等待队列中的第一个PCB加入就绪队列的对尾
          if(wait.size()>0){
             waittoready(ready,wait); 
          }
      }
      System.out.println("\n\n所有进程执行完毕!");
  }    


//基于优先数的调度算法函数
  static void call_PrevSort(LinkedList<Process> ready,LinkedList<Process> wait){
      int time=0;        //处理机分配的时间片
      Random rd=new Random();
      Process pro_hightsort;

      while(ready.size()>0 || wait.size()>0){
          process_Print(ready,wait);      //输出所有进程信息
          time=rd.nextInt(15)+5;   //随机产生时间片长度
          System.out.println("\n时间片长度： "+time);

          if(ready.size()>0){
             pro_hightsort=search_HightSort(ready);       //寻找一个优先数最高的进程

             System.out.print("进程"+pro_hightsort.getName()+"优先数最高。  ");
             if(pro_hightsort.getTime() > time){        //进程执行所需时间大于处理机分配的时间片，执行完时间片长度后
                 pro_hightsort.setTime(pro_hightsort.getTime()-time); //该进程随机进入等待或就绪对列，
                 if(rd.nextInt(2)==0){                                         //否则该进程执行完毕删除该进程
                     ready.add(pro_hightsort);
                     System.out.print("进程："+pro_hightsort.getName()+" 时间片不够进入就绪对列队尾。  ");
                 }
                  else{
                     wait.add(pro_hightsort);
                     System.out.print("进程："+pro_hightsort.getName()+" 时间片不够进入等待对列队尾。  ");
                  }
             }
             else 
                System.out.print("进程："+pro_hightsort.getName()+" 执行完毕！  ");

             ready.remove(ready.indexOf(pro_hightsort)); 
          }
          //在进程执行过程中，产生随机数0或1，该随机数为1时，将等待队列中的第一个PCB加入就绪队列的对尾
          if(wait.size()>0){
             waittoready(ready,wait); 
          }
      }
      System.out.println("\n\n所有进程执行完毕!");
  } 


//最短执行时间调度算法函数

  static void call_LessTime(LinkedList<Process> ready,LinkedList<Process> wait){
      int time=0;        //处理机分配的时间片
      Random rd=new Random();
      Process pro_lesstime;
    
      while(ready.size()>0 || wait.size()>0){
     
          process_Print(ready,wait);      //输出所有进程信息
          time=rd.nextInt(15)+5;   //随机产生时间片长度
          System.out.println("\n时间片长度： "+time);

          if(ready.size()>0){
             pro_lesstime=search_LessTime(ready);
             System.out.print("进程"+pro_lesstime.getName()+"执行时间最短。  ");
             if(pro_lesstime.getTime() > time){        //进程执行所需时间大于处理机分配的时间片，执行完时间片长度后
                 pro_lesstime.setTime(pro_lesstime.getTime()-time); //该进程随机进入等待或就绪对列，
                 if(rd.nextInt(2)==0){                                         //否则该进程执行完毕删除该进程
                     ready.add(pro_lesstime);
                     System.out.print("进程："+pro_lesstime.getName()+" 时间片不够进入就绪对列队尾。  ");
                 }
                  else{
                     wait.add(pro_lesstime);
                     System.out.print("进程："+pro_lesstime.getName()+" 时间片不够进入等待对列队尾。  ");
                  }
             }
             else 
                System.out.print("进程："+pro_lesstime.getName()+" 执行完毕！  ");

             ready.remove(ready.indexOf(pro_lesstime)); 
          }

       //在进程执行过程中，产生随机数0或1，该随机数为1时，将等待队列中的第一个PCB加入就绪队列的对尾
          if(wait.size()>0){
             waittoready(ready,wait); 
          }
      }
      System.out.println("\n\n所有进程执行完毕!");
  } 

//在进程执行过程中，产生随机数0或1，该随机数为1时，将等待队列中的第一个PCB加入就绪队列的对尾；
  static void waittoready(LinkedList<Process> ready,LinkedList<Process> wait){
       Random rd=new Random();
       if(rd.nextInt(2)==1){
           ready.add(wait.get(0));
           System.out.println("等待队列第一个进程: "+wait.get(0).getName()+" 进入就绪对列队尾!");
       }
       else{
           wait.add(wait.get(0));
           System.out.println("等待队列第一个进程: "+wait.get(0).getName()+" 进入等待对列队尾!");
       }
      wait.remove(0);
  }

//寻找一个所需时间最少的进程
 static Process search_LessTime(LinkedList<Process> ready){
      Process lesstime=ready.get(0);

      for(int i=1;i<ready.size();i++){
         if(lesstime.getTime()>ready.get(i).getTime())
            lesstime=ready.get(i);
      }
      return lesstime;    
  }

//寻找一个优先数最高的进程
   static Process search_HightSort(LinkedList<Process> ready){
      Process hightsort=ready.get(0);

      for(int i=1;i<ready.size();i++){
         if(hightsort.getSort()<ready.get(i).getSort())
            hightsort=ready.get(i);
      }
      return hightsort;    
   }

}