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();
    }
}