首先：这不是家庭作业，它是我的朋友，她已经完成并提交，我很好奇它是如何工作的，因为我从来没有写过队列模拟之前并决定试一试。
基本上，我们给了一个Job ADT，并且应该编写一个正常运行的Queue ADT，它具有常规队列操作，如delete（）和insert（）。使用这两个ADTS我正在尝试编写一个作业队列模拟，其中有一个输入文件给出了第1行的列表：要处理的作业数，文件中的所有其他行都有一对数字代表到达时间每行的每个工作的持续时间。作业多于处理器，作业由（到达时间，持续时间，结束时间）组成。
模拟的目标是确定
我已根据LinkedList编写了一个功能性队列ADT，但我很遗憾我应该如何同时使用Job ADT和Queue ADT Simulation个文件。我知道我的Queue ADT有效，所以我只是为了节省空间而包含了接口文件。我也有一些代码和一些伪代码用于我正在研究的模拟文件。如果我能得到一点推/一些示例代码，我可能会从那里找到我的方式。请帮忙！ :)谢谢你
示例输入文件：
3,
2 2,
3 4,
5 6,
input.rpt文件（由simulation.java创建的报告文件）：
报告文件：
3 Jobs:
(2, 2, *) (3, 4, *) (5, 6, *)
***********************************************************
1 processor: totalWait=4, maxWait=3, averageWait=1.33
2 processors: totalWait=0, maxWait=0, averageWait=0.00
input.trc文件（simulation.java创建的跟踪文件）：
跟踪文件：
3 Jobs:
(2, 2, *) (3, 4, *) (5, 6, *)
*****************************
1 processor:
*****************************
time=0
0: (2, 2, *) (3, 4, *) (5, 6, *)
1:
time=2
0: (3, 4, *) (5, 6, *)
1: (2, 2, 4)
time=3
0: (5, 6, *)
1: (2, 2, 4) (3, 4, *)
time=4
0: (5, 6, *) (2, 2, 4)
1: (3, 4, 8)
time=5
0: (2, 2, 4)
1: (3, 4, 8) (5, 6, *)
time=8
0: (2, 2, 4) (3, 4, 8)
1: (5, 6, 14)
time=14
0: (2, 2, 4) (3, 4, 8) (5, 6, 14)
1:
*****************************
2 processors:
*****************************
time=0
0: (2, 2, *) (3, 4, *) (5, 6, *)
1:
2:
time=2
0: (3, 4, *) (5, 6, *)
1: (2, 2, 4)
2:
time=3
0: (5, 6, *)
1: (2, 2, 4)
2: (3, 4, 7)
time=4
0: (5, 6, *) (2, 2, 4)
1:
2: (3, 4, 7)
time=5
0: (2, 2, 4)
1: (5, 6, 11)
2: (3, 4, 7)
time=7
0: (2, 2, 4) (3, 4, 7)
1: (5, 6, 11)
2:
time=11
0: (2, 2, 4) (3, 4, 7) (5, 6, 11)
1:
2:
Job ADT：
import java.io.*;
public class Job{
public static final int UNDEF = -1;
private int arrival;
private int duration;
private int finish;
// default constructor
public Job(int arrival, int duration){
this.arrival = arrival;
this.duration = duration;
this.finish = UNDEF;
}
// access functions
public int getArrival(){return arrival;}
public int getDuration(){return duration;}
public int getFinish(){return finish;}
public int getWaitTime(){
if( finish==UNDEF ){
System.err.println("Job: getWaitTime(): undefined finish time");
System.exit(1);
}
return finish-duration-arrival;
}
// manipulation procedures
public void computeFinishTime(int timeNow){finish = timeNow + duration;}
public void resetFinishTime(){finish = UNDEF;}
// toString
// overrides Object's toString() method
public String toString(){
return "("+arrival+", "
+duration+", "
+(finish==UNDEF?"*":String.valueOf(finish))+")";
}
}
队列接口：列出队列ADT执行的操作
public interface QueueInterface{
// isEmpty()
// pre: none
// post: returns true if this Queue is empty, false otherwise
public boolean isEmpty();
// length()
// pre: none
// post: returns the length of this Queue.
public int length();
// enqueue()
// adds newItem to back of this Queue
// pre: none
// post: !isEmpty()
public void enqueue(Object newItem);
// dequeue()
// deletes and returns item from front of this Queue
// pre: !isEmpty()
// post: this Queue will have one fewer element
public Object dequeue() throws QueueEmptyException;
// peek()
// pre: !isEmpty()
// post: returns item at front of Queue
public Object peek() throws QueueEmptyException;
// dequeueAll()
// sets this Queue to the empty state
// pre: !isEmpty()
// post: isEmpty()
public void dequeueAll() throws QueueEmptyException;
// toString()
// overrides Object's toString() method
public String toString();
}
到目前为止，我在Simulation.java中拥有的内容
import java.io.*;
import java.util.Scanner;
import java.util.Queue;
import java.util.Job;
public class Simulation{
public static Job getJob(Scanner in) {
String[] s = in.nextLine().split(" ");
int a = Integer.parseInt(s[0]);
int d = Integer.parseInt(s[1]);
return new Job(a, d);
}
public static void main(String[] args) throws IOException{
Scanner in = null;
PrintWriter in.rpt = null;
PrintWriter in.trc = null;
in = new Scanner(new File(args[0]);
in.rpt = new PrintWriter(new FileWriter);
in.trc = new PrintWriter(new FileWriter);
in.useDelimiter("\n");
int m = in.next();
for(int i = 1; i<m; i++){
System.out.println(getJob(Scanner in));
}
int n = 1;
while(n<m){
Queue[] Processors = new Queue[n];
Processor[0] = new Queue();
Queue[] Backup = new Queue[n];
// Pseudo code for Simulation
// 1. check command line arguments
//
// 2. open files for reading and writing
//
// 3. read in m jobs from input file
//
// 4. run simulation with n processors for n=1 to n=m-1 {
//
// 5. declare and initialize an array of n processor Queues and any
// necessary storage Queues
//
// 6. while unprocessed jobs remain {
//
// 7. determine the time of the next arrival or finish event and
// update time
//
// 8. complete all processes finishing now
//
// 9. if there are any jobs arriving now, assign them to a processor
// Queue of minimum length and with lowest index in the queue array.
//
// 10. } end loop
//
// 11. compute the total wait, maximum wait, and average wait for
// all Jobs, then reset finish times
//
// 12. } end loop
//
// 13. close input and output files
答案 0 :(得分：0)
作为Java（我的第一门编程语言）的学习者，我遇到了类似的心理障碍，为作业和爱好设计程序。因此，我觉得我最近克服类似的类交互混淆的经验可能有助于OP，并且社区可以提供的任何答案，专注于设计过程而不是代码片段将有助于OP，其他学习者和我
分解要求：
示例报告文件提供了必要结构的线索，以及状态更改触发报告的内容。 ＆＃34;时间：x＆＃34;线条表示您需要人为地保留时间，并且该片段内的所有内容都会循环播放，包括报告。您的伪代码的第6步中的循环是最早的似乎是合理的。
线条仅在作业开始或完成时打印到报告，而不是每次打印可能相同的报告时＃34;时钟＆＃34;增量。一个作业在出列时就开始了，那么一个空的队列真的意味着没有正在进行的作业吗？该问题的答案决定了某些片段在逻辑结构中的位置。
Job.getWaitTime（）仅在作业启动后返回一个值。完成时间由Job.computeFinishTime（）通过传递Job到达处理器的时间来计算，并且不需要时间来传递到设置完成。只在合适的时间调用此方法。
我的一个新手错误是将所有等待时间存储在一个数组中，而不是仅存储到目前为止看到的最大值。 AFAIK不需要存储更多，而Simulation应该有一个实例变量来存储它。
如果你取得了进展，我会发现在下一个断点看代码是有益的。
P.S。我（学习者）对ADT的理解是，队列ADT在泛型中更好，或者特定于Jobs而不是Objects。