如何让我的Java程序终止？

Question

我正在做一个关于模拟正在处理的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;
}

}

Answer 1

您的SLPQueue（）不会减少它的size值。它只是在这里和那里增加。因此，isempty（）永远不会返回true，主循环中的空永远不会得到true，因此您的程序永远不会结束。

所以将RemveMin（）更改为

public Node removeMin() throws EmptyPriorityQueueException {        // removal method to remove from head of list
    if (entries.isEmpty()) throw new EmptyPriorityQueueException("Priority Queue is empty.");
    else {
        size--;
        return entries.removeFirst();
    }
}

Answer 2

我打赌Q.isEmpty（）的行为与您希望的不一样。它看起来像是在队列的size上运行，但是您的removeMin方法没有递减该值。

尝试添加size--；到SLPQueue.removeMin中的其他块