先来先服务算法实现

Question

这是我们教授给我们的一个项目。

要求是在JAVA中实现3个预先挑选的CPU调度算法。 我们的团队获得了FCFS（先来先服务），Round Robin和MFQ（多反馈队列）算法。

现在我做了这个FCFS代码：

import java.util.Vector; 


public class FCFS 
{ 
    protected int[] arrivalTime; 
    protected int[] burstTime; 
    protected int[] job; 
    protected int[] jobIdle; 
    protected int numberOfProcess; 
    protected int[] waitingTime; 
    protected int[] finishedTime; 
    protected int averageWT,averageTTsum; 
    protected int jobs; 

    public FCFS (int[] aT,int[] bT,int[] job,int num) 
    { 
     arrivalTime = aT; 
     burstTime = bT; 
     this.job = job; 
     numberOfProcess = num; 
     waitingTime = new int[numberOfProcess]; 
     finishedTime = new int[numberOfProcess]; 
     jobs = 0; 
    } 

public void FCFS() 
{ 
    int firstCome,tempArrivalTime,tempBurst; 
//sort processes 
    for (int i = 0; i < (numberOfProcess - 1); i++) 
    { 
    for (int j = (i + 1); j < numberOfProcess; j++) 
    { 
     if (arrivalTime[j] < arrivalTime[i]) 
     { 

      firstCome = job[j]; 
      job[j] = job[i]; 
      job[i] = firstCome; 
      tempArrivalTime = arrivalTime[j]; 
      arrivalTime[j] = arrivalTime[i]; 
      arrivalTime[i] = tempArrivalTime; 
      tempBurst = burstTime[j]; 
      burstTime[j] = burstTime[i]; 
      burstTime[i] = tempBurst; 

       } 

     } 

    } 

    System.out.println("\n==Displaying Table of Jobs Sorted According to Arrival Time=="); 
    displaySorted(); 
    System.out.println("======DISPLAYING GANTT CHART======"); 
    solveWaitingTime(); 
    solveAverageTime(); 


} 
public void solveAverageTime() 
{ 
    //ATT 
    for(int i = 0;i<numberOfProcess;i++) 
    averageTTsum = averageTTsum+(finishedTime[i]-arrivalTime[i]); 
    //AWT 
    for(int j=0;j<numberOfProcess;j++) 
     averageWT = averageWT+(waitingTime[j] - arrivalTime[j]); 


    double aTT = (float)averageTTsum/numberOfProcess; 
    double aWT=(float)averageWT/numberOfProcess; 
    System.out.format("ATT: %.2f ",aTT); 
    System.out.println(""); 
    System.out.format("AWT: %.2f ",aWT); 
} 

public void solveWaitingTime() 
{ int ctr=0; 
    Vector<Integer> idleWT = new Vector<Integer>(); 
    Vector<Boolean> idle = new Vector<Boolean>(); 
    for(int z = 0; z < numberOfProcess; z++) //run through all processes 
    { 
     if(ctr > arrivalTime[z])      //if counter is greater than the arrival time 
     {idle.add(Boolean.TRUE);       //an idle time is not needed hence TRUE 
      for(int k = 0; k < burstTime[z]; k++)  //do burst time of current process 
      { 

      ctr++;        

       } 
      jobs++; 

     } 
     else          //if counter is less than arrival time 
     { 
      while(ctr <= arrivalTime[z]) 
      { 
       if(ctr == arrivalTime[z])     //if counter is equal to arrivalTime 
       { 
        jobs++;         
        for(int j = arrivalTime[z]; j < (arrivalTime[z] + burstTime[z]); j++)//starting from arrival time 
         {                //do the burst time of process 
          ctr++; 

         } 
        idle.add(Boolean.TRUE);    
       } 
       else         //if not equal to arrival time 
       { 
        jobs++;    
       ctr++;          //an idle time will be consumed 
        idle.add(Boolean.FALSE);    //idle has been detected 
       } 

      } 

      } 

     finishedTime[z] = ctr;     //turn-around time is = to total counter 
     if(z==0)        //if time is 0 
     idleWT.add(0);       //IdlewaitingTime of first process is 0 
     else idleWT.add(ctr);     //else ctr 
} 
    waitingTime[0] = 0; 
    for(int z = 1;z<numberOfProcess;z++) 
    { 
     waitingTime[z] = finishedTime[z] - burstTime[z];//compute waiting time 

    } 

//debugging purposes 
    /* for(int i = 0;i<numberOfProcess;i++) 
    { System.out.print("arrival: "+arrivalTime[i]); 
     System.out.print("burst: "+burstTime[i]); 
     System.out.print("wait: "+waitingTime[i]); 
     System.out.print("finished: "+finishedTime[i]); 

    }*/ 
    System.out.println(""+idleWT.toString());    //debugging purposes 
     System.out.println(""+idle.toString()); //debugging purposes 
     System.out.println("Jobs: "+jobs); //debugging purposes 
     int ctr2 = 0; 

    for(int y = 0; y < numberOfProcess; y++)  //displays gannt Chart 
     { 
      if(idle.elementAt(ctr2)==false)       //if an idle time is detected 
      { if(ctr2==0) 
      {System.out.print("|I"+(waitingTime[y+1])+" |"); ctr2++;} //print an I to symbolize idle time and its burst time 
      else { 
       System.out.print("|I "+(idleWT.elementAt(y)-waitingTime[y])+" |"); 
       ctr2++; 
      } 

      } 
      System.out.print("|P"+job[y]+"("+burstTime[y]+")"+" |");   //else print name of processes 
      ctr2++; 
     } 
    System.out.println(""); 
    //gantt chart time display 
    for(int x = 0;x<numberOfProcess;x++) 
    { if(idleWT.elementAt(x) == 0) 
     System.out.print(""+waitingTime[x]); 
    else System.out.print("  "+waitingTime[x]+ "  "+idleWT.elementAt(x)); 
    } 
    System.out.println(""); 
} 

public void displaySorted() 
{ 
    System.out.println("\n------------------------------------"); 

    System.out.println("Process | Arrival Time | CPU Burst "); 


    for(int y = 0; y < numberOfProcess; y++) 
     { 
      System.out.println("P" + job[y] + "\t\t" 
      + arrivalTime[y] +"\t  " 
      + burstTime[y]); 

     } 

    System.out.println("------------------------------------\n"); 
    } 

} 

的输出应该是这样的：

Enter Number of processes: 5 //sample only 
Enter Arrival time of p1: 
Enter Burst Time of p1: 
. 
. 
. 
. 
. 
. 
. 
. 
Enter Arrival time of p5: 
Enter Burst Time of p5: 
==Displaying Table of Jobs Sorted According to Arrival Time== 

------------------------------------ 
Process | Arrival Time | CPU Burst 

p1 
p2 
p3 
p4 
p5 

======DISPLAYING GANTT CHART====== 
    p1(burst) | p2(burst2) | ..... 
0  burst|  burst2| ..... 

AWT: 
ATT: 

现在我有我的代码的问题，可能忽略了太多看问题和这些是：

1. 它不记录空闲时间的正确突发时间
2. 它不显示适当数量的海啸图中的空闲时间
3. 我认为会有一个输入，将完全搞乱我的程序。
4. 此外，我已经宣布了一些变量，起初我认为我可以使用，但后来我改变了主意，决定不使用它们。
5. 我也觉得这个算法在我的逻辑中存在缺陷，请指出来，这对我的学习会有很大的帮助。

我该如何解决这些问题？ 我希望我已经提供了足够的信息。

Answer 1

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.IO; 

namespace FCFS_Console 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      //----------------------------------------Reading I/O File-------------------------------------- 
      string s = Environment.CurrentDirectory.ToString(); // returns the directory of the exe file 
      if (File.Exists(s + @"\input.txt")) //checking if the input files exists 
       Console.WriteLine("File Exists"); 
      else 
      { 
       Console.WriteLine("File Not Found"); 
       Console.WriteLine("_________________________________________________________________"); 
       return; 
      } 
      Console.WriteLine("_________________________________________________________________"); 
      //----------------------------------------Data Into List-------------------------------------- 
      string FileText = File.ReadAllText(s + @"\input.txt"); //reading all the text in the input file 
      string[] lines = FileText.Split('\n'); //splitting the lines 
      List<Process> processes = new List<Process>(); 
      for (int i = 1; i < lines.Length; i++) 
      { 
       string[] tabs = lines[i].Split('\t');//splitting the tabs to get objects' variables 
       Process x = new Process(tabs[0], int.Parse(tabs[1]), int.Parse(tabs[2]), int.Parse(tabs[3]));//creating object 
       processes.Add(x);//adding object to the list 
      } 
      // ----------------------------------------Sorting The List-------------------------------------- 
      Process temp; 
      for (int k = 0; k < processes.Count; k++) 
      { 
       for (int i = k + 1; i < processes.Count; i++) 
       { 
        if (processes[k].arrivalTime > processes[i].arrivalTime || (processes[k].arrivalTime == processes[i].arrivalTime && processes[k].brust > processes[i].brust)) 
        { 
         temp = processes[i]; 
         processes[i] = processes[k]; 
         processes[k] = temp; 
        } 
       } 
      } 
      Console.WriteLine("Processes After Sorting"); 
      Console.WriteLine("_________________________________________________________________"); 
      Console.WriteLine("Name\tArrival\tBrust\tPriority"); 
      for (int i = 0; i < processes.Count; i++) 
      { 
       Console.Write(processes[i].name + "\t" + processes[i].arrivalTime + "\t" + processes[i].brust + "\t" + processes[i].priority); 
       Console.WriteLine(); 
      } 
      Console.WriteLine("_________________________________________________________________"); 
      //----------------------------------------Gantt Chart-------------------------------------- 
      Console.WriteLine("Gantt Chart"); 
      Console.WriteLine("_________________________________________________________________"); 
      int counter = 0; 
      for (int i = 0; i < processes.Count; i++) 
      { 
       Console.Write(processes[i].name + "\t"); 
       if (processes[i].arrivalTime < counter) 
        printSpaces(counter); 
       else 
       { 
        printSpaces(processes[i].arrivalTime); 
        counter = processes[i].arrivalTime; 
       } 
       printHashes(processes[i].brust); 
       counter += processes[i].brust; 
       Console.WriteLine(); 
      } 
      Console.WriteLine("_________________________________________________________________"); 
      //-----------------------------------Completing Data And final Table------------------------- 
      int clock = 0, totalwait = 0, totalturnAround = 0; 
      for (int i = 0; i < processes.Count; i++) 
      { 
       if (processes[i].arrivalTime > clock) 
       { 
        processes[i].start = processes[i].arrivalTime; 
        clock += processes[i].start - processes[i].arrivalTime; 
        clock += processes[i].brust; 

       } 
       else 
       { 
        if (i > 0) 
         processes[i].start = processes[i - 1].end; 
        clock += processes[i].brust; 
       } 
       if (processes[i].start > processes[i].arrivalTime) 
        processes[i].wait = processes[i].start - processes[i].arrivalTime; 
       else processes[i].wait = 0; 
       processes[i].end = processes[i].start + processes[i].brust; 
       processes[i].turnAround = processes[i].wait + processes[i].brust; 
       totalwait += processes[i].wait; 
       totalturnAround += processes[i].turnAround; 
      } 
      Console.WriteLine("Name\tArrival\tBrust\tStart\tEnd\tWait\tturnaround"); 
      for (int i = 0; i < processes.Count; i++) 
      { 
       Console.Write(processes[i].name + "\t" + processes[i].arrivalTime + "\t" + processes[i].brust + "\t" + processes[i].start + "\t" + processes[i].end + "\t" + processes[i].wait + "\t" + processes[i].turnAround); 
       Console.WriteLine(); 
      } 
      double att = 0, awt = 0; 
      awt = (double)totalwait/(double)processes.Count; 
      att = (double)totalturnAround/(double)processes.Count; 
      Console.WriteLine("A.W.T= " + awt + "\t A.T.T= " + att); 
      Console.ReadKey(); 
     } 
     public static void printSpaces(int counter) 
     { 
      for (int i = 0; i < counter; i++) 
      { 
       Console.Write(" "); 
      } 
     } 
     public static void printHashes(int brust) 
     { 
      for (int i = 0; i < brust; i++) 
      { 
       Console.Write("#"); 
      } 
     } 

    } 
} 


class Process 
{ 
    public Process(string name, int arrivalTime, int brust, int priority) 
    { 
     this.name = name; 
     this.arrivalTime = arrivalTime; 
     this.brust = brust; 
     this.priority = priority; 
    } 
    public Process() 
    { 

    } 
    public string name; 
    public int arrivalTime; 
    public int brust; 
    public int priority; 
    public int wait; 
    public int end; 
    public int start; 
    public int turnAround; 
}