Java实现进程调度算法(一) FCFS(先来先服务)

一、概述

　　因为这次os作业对用户在控制台的输入输出有要求，所以我花了挺多的代码来完善控制台的显示。

　　也因为我这次要实现多个类似算法，所以将一些共性单独提取出来作为一个类。　　

　　如果只想要和算法有关的核心代码，看FCFS类的calc()即可。

　　实现思路：按照顺序将进程添加到列表中，然后再按照添加顺序运行。模拟进程的运行，即为按顺序改变每个进程的到达时间、服务时间、开始时间、等待时间、周转时间和带权周转时间。在所有进程都结束后再计算平均周转时间和平均带权周转时间。

三、测试

　　1. 测试数据：

　　2. 运行结果：

三、流程图

四、实现代码

　　1. FCFS类（主类）

只有calc()中涉及了算法，init()和printResult()只有简单的输入输出操作。

 package xqy.algorithm;

 import java.util.ArrayList;
 import java.util.Scanner;

 import xqy.Util.Tools;
 import xqy.been.Process;

 /**
  * @author xqy
  * @date 2018年12月19日19:15:01
  * @description 对先到的任务先处理，后到的任务后处理。
  */

 public class FCFS {
     private int processNumber;
     private ArrayList<Process> processList;

     public FCFS() {
         init();
         calc();
         Tools.printResult(processList);
     }

     private void init() {
         Scanner sc = new Scanner(System.in);

         System.out.print("<FCFS> Please enter the process num:");
         processNumber = sc.nextInt();

         processList = new ArrayList<Process>();
         for (int i = 0; i < processNumber; i++) {
             processList.add(new Process());
         }

         System.out.println("<FCFS> Please enter each process arrival time:");
         for (int i = 0; i < processNumber; i++) {
             System.out.print("    Process" + (i + 1) + ":");
             processList.get(i).setArrivalTime(sc.nextInt());
         }

         System.out.println("<FCFS> Please enter each process service time:");
         for (int i = 0; i < processNumber; i++) {
             System.out.print("    Process" + (i + 1) + ":");
             processList.get(i).setServicesTime(sc.nextInt());
         }
     }

     private void calc() {
         int timeNow = 0;
         Process opProcess;

         for (int i = 0; i < processNumber; i++) {
             opProcess = processList.get(i);

             int waitTime = timeNow - opProcess.getArrivalTime();
             int completionTime = timeNow + opProcess.getServicesTime();
             int turnAroundTime = completionTime
                     - opProcess.getArrivalTime();
             double turnAroundTimeWithWeight = (double) turnAroundTime
                     / opProcess.getServicesTime();

             opProcess.setStartTime(timeNow);
             opProcess.setWaitTime(waitTime);
             opProcess.setCompletionTime(completionTime);
             opProcess.setTurnAroundTime(turnAroundTime);
             opProcess.setTurnAroundTimeWithWeight(
                     turnAroundTimeWithWeight);

             timeNow += opProcess.getServicesTime();
         }
     }

     public static void main(String [] args) {
         new FCFS();
     }
 }

　　2. Process类

模拟了进程，对属性进行了封装。

 package xqy.been;

 public class Process {
     private int arrivalTime;
     private int servicesTime;
     private int remainServiceTime;
     private int startTime;
     private int waitTime;
     private int completionTime;

     /**
      * turnAroundTime = completionTime - arrivalTime
      */
     private int turnAroundTime;

     /**
      * turnAroundTimeWithWeight = turnAroundTime / servicesTime
      */
     private double turnAroundTimeWithWeight;

     public Process() {
         ;
     }

     public int getArrivalTime() {
         return arrivalTime;
     }

     public void setArrivalTime(int arrivalTime) {
         this.arrivalTime = arrivalTime;
     }

     public int getServicesTime() {
         return servicesTime;
     }

     public void setServicesTime(int servicesTime) {
         this.servicesTime = servicesTime;
     }

     public int getRemainServiceTime() {
         return remainServiceTime;
     }

     public void setRemainServiceTime(int remainServiceTime) {
         this.remainServiceTime = remainServiceTime;
     }

     public int getStartTime() {
         return startTime;
     }

     public void setStartTime(int startTime) {
         this.startTime = startTime;
     }

     public int getWaitTime() {
         return waitTime;
     }

     public void setWaitTime(int waitTime) {
         this.waitTime = waitTime;
     }

     public int getCompletionTime() {
         return completionTime;
     }

     public void setCompletionTime(int completionTime) {
         this.completionTime = completionTime;
     }

     public int getTurnAroundTime() {
         return turnAroundTime;
     }

     public void setTurnAroundTime(int turnAroundTime) {
         this.turnAroundTime = turnAroundTime;
     }

     public double getTurnAroundTimeWithWeight() {
         return turnAroundTimeWithWeight;
     }

     public void setTurnAroundTimeWithWeight(double turnAroundTimeWithWeight) {
         this.turnAroundTimeWithWeight = turnAroundTimeWithWeight;
     }

     @Override
     public String toString() {
         return "Process [arrivalTime=" + arrivalTime + ", servicesTime="
                 + servicesTime + ", remainServiceTime=" + remainServiceTime
                 + ", startTime=" + startTime + ", waitTime=" + waitTime
                 + ", completionTime=" + completionTime + ", turnAroundTime="
                 + turnAroundTime + ", turnAroundTimeWithWeight="
                 + turnAroundTimeWithWeight + "]";
     }
 }

　　3. Tools类

因为这次要实现几个类似的算法，所以我把每个算法中都要用到的方法都提取出来作为单独的工具类。

也可以将这些工具方法都放入FCFS类中。

 package xqy.Util;

 import java.util.ArrayList;

 import xqy.been.Process;

 public class Tools {

     public static double calcAverageTurnAroundTime(
             ArrayList<Process> processList) {
         double sum = 0;
         for (int i = 0; i < processList.size(); i++) {
             sum += processList.get(i).getTurnAroundTime();
         }
         return Math.round(sum / processList.size() * 100) / 100.0;
     }

     public static double calcAverageTurnAroundTimeWithWeight(
             ArrayList<Process> processList) {
         double sum = 0;
         for (int i = 0; i < processList.size(); i++) {
             sum += processList.get(i).getTurnAroundTimeWithWeight();
         }
         return Math.round(sum / processList.size() * 100) / 100.0;
     }

     public static void printResult(ArrayList<Process> processList) {
         System.out.println("\n    #RESULT#");

         System.out.print("\tArrive:\t\t");
         for (int i = 0; i < processList.size(); i++) {
             System.out.print(processList.get(i).getArrivalTime() + "\t");
         }
         System.out.println();

         System.out.print("\tService:\t");
         for (int i = 0; i < processList.size(); i++) {
             System.out.print(processList.get(i).getServicesTime() + "\t");
         }
         System.out.println();

         System.out.print("\tStart:\t\t");
         for (int i = 0; i < processList.size(); i++) {
             System.out.print(processList.get(i).getStartTime() + "\t");
         }
         System.out.println();

         System.out.print("\tWait:\t\t");
         for (int i = 0; i < processList.size(); i++) {
             System.out.print(processList.get(i).getWaitTime() + "\t");
         }
         System.out.println();

         System.out.print("\tFinish:\t\t");
         for (int i = 0; i < processList.size(); i++) {
             System.out.print(processList.get(i).getCompletionTime() + "\t");
         }
         System.out.println();

         System.out.print("\tTurn around:\t");
         for (int i = 0; i < processList.size(); i++) {
             System.out.print(processList.get(i).getTurnAroundTime() + "\t");
         }
         System.out.println();

         System.out.print("\tTA wight:\t");
         for (int i = 0; i < processList.size(); i++) {
             System.out.print(Math.round(processList.get(i)
                     .getTurnAroundTimeWithWeight() * 100) / 100.0 + "\t");
         }
         System.out.println();

         System.out.println("\tAverage turn around time:"
                 + Tools.calcAverageTurnAroundTime(processList) + "\t");
         System.out.println("\tAverage turn around time with wight:"
                 + Tools.calcAverageTurnAroundTimeWithWeight(processList));

         System.out.println();
     }
 }