我正在做一个模拟正在处理的 CPU 作业的项目。基本上，用户将输入一个作业，其长度将被处理和一个优先级键（从-20 到 19，从 -20 开始以获得更高的优先级）。到目前为止，除了程序正确终止之外，我已经完成了所有这些工作。基本上，当我的优先级队列中的所有作业都已处理完毕时，我需要程序终止。当每个作业被处理时，它会从长度中减去，直到它为 0。当它为 0 时，它将从优先级队列中删除。当没有剩余作业时（优先队列为空），程序应在输入 n 后终止，因为没有新作业。但是由于某种原因，我完成代码的方式并没有终止。相反，当我输入 n 时，它给了我一个空指针错误，而没有工作要输入。谁能指出我可能在哪里犯了错误？谢谢。
示例输入-输出过程如下所示，格式如下（作业名称、长度、优先级）：
输入要处理的作业：
I:job1 3 0
O:job1输入要处理的新工作：
I:n
O:job1输入要处理的新工作：
I:job2 1 -3
O:job2输入要处理的新工作：
I:n
O:job1输入要处理的新工作：
I:n
这是我的代码：
import java.util.Scanner;
import java.lang.Integer;
public class PQScheduler {
String command = "";
String process = "";
String[] inputParts = null;
SLPQueue Q;
boolean empty = false;
PQScheduler(String inputCommand) {
Q = new SLPQueue();
Scanner comReader = new Scanner(System.in);
this.command = inputCommand;
this.inputParts = command.split("\\s"); // will split input at whitespace and store parts into array
while (empty == false) { // will loop until priority queue becomes empty
if (this.inputParts[0].equals("n")) { // input of no new jobs, will continue processing previous jobs however
if (Q.isEmpty()) {
System.exit(0);
}
else {
this.process(Q.entries.getHead(), Q.entries.getHead().getValue());
}
}
else {
int value = Integer.parseInt(inputParts[1]); // parses value of length into an integer
int key = Integer.parseInt(inputParts[2]); // parse value of key into an integer
try {
Q.insert(inputParts[0], key, value); // inserts job, length, and key into priority queue
} catch (InvalidKeyException e) {
e.printStackTrace();
}
this.process(Q.entries.getHead(), Q.entries.getHead().getValue()); // processes the highest priority job
}
System.out.println("Enter new job to be processed: ");
command = comReader.nextLine();
inputParts = command.split("\\s");
}
}
public void process(Node n, int value) {
if (value == 0) {
try {
Q.removeMin(); // removes the finished job
if (Q.isEmpty()) {
empty = true;
}
else {
process(Q.entries.getHead(), Q.entries.getHead().getValue()); // processes next highest priority job
}
} catch (EmptyPriorityQueueException e) {
e.printStackTrace();
}
}
else {
n.setValue(value - 1); // decrements job length by 1 when processed
process = n.getElement();
System.out.println(process);
}
}
public static void main(String[] args) {
String inputCommand = "";
Scanner mainReader = new Scanner(System.in);
System.out.println("Enter the job to be processed: "); // takes in user input of job, length, and priority
inputCommand = mainReader.nextLine();
PQScheduler scheduler = new PQScheduler(inputCommand);
}
}
public class SLPQueue implements PQueue {
protected SLList entries;
protected int size;
public SLPQueue() {
entries = new SLList(); // creates a new linked list to store elements
size = 0;
}
public String min() throws EmptyPriorityQueueException {
if(entries.isEmpty()) throw new EmptyPriorityQueueException("Priority Queue is empty.");
else
return entries.getHead().getElement(); // gets the first node in priority queue
}
public Node insert(String e, int k, int v) throws InvalidKeyException {
Node tempNode = new Node(e, k, v, null);
insertEntry(tempNode);
return tempNode; // insertion method to add values to node and then insert into priority queue
}
protected void insertEntry(Node n) { // insertion method to add into priority queue
if (entries.isEmpty()) { // checks if it is empty, if so, it will make it head of list
entries.addFirst(n);
size++;
}
else if (compare(n.getKey(), entries.getTail().getKey()) > 0) { // checks to see if lower priority key inserted
entries.addLast(n); // adds last if key inserted is lower priority than the current tail of list
size++;
}
else if (compare(n.getKey(), entries.getHead().getKey()) < 0) {
entries.addFirst(n); // adds first if key inserted is higher priority than the current head of list
size++;
}
else {
Node temp1 = entries.getHead(); // starts traversal from beginning of list
Node temp2 = temp1; // creates a second temporary node to "capture" node for node n to be inserted after
while (compare(n.getKey(), temp1.getKey()) > 0 ) { // loop to see if keys are of lower priority
if (temp1.equals(entries.getHead())) { // if statement created to set back temp2 by one node
temp1 = temp1.getNext();
}
else {
temp2 = temp2.getNext(); // gets the node value before temp1
temp1 = temp1.getNext(); // gets the next temp1 value
}
}
temp2.setNext(n); // loop will break when key has higher priority than temp1 key found
n.setNext(temp1);
size++;
}
}
public int compare(int k1, int k2) { // comparator method to check for key priorities
int compare = 0;
if (k1 >= k2) {
compare = 1; // returns 1 if first key is of lower priority than second key
}
else if (k1 < k2) { // returns -1 if first key is of higher priority than second key
compare = -1;
}
return compare;
}
public Node removeMin() throws EmptyPriorityQueueException { // removal method to remove from head of list
if (entries.isEmpty()) throw new EmptyPriorityQueueException("Priority Queue is empty.");
else {
return entries.removeFirst();
}
}
public int size() { // returns size of priority queue list
return size;
}
public boolean isEmpty() { // checks to see if priority queue list is empty
return size == 0;
}
}