3

这对我来说有点复杂，所以请多多包涵。我正在模拟分配 PID 的进程标识符 (PID) 管理器。它已扩展为包含一个多线程程序，该程序将分配 PID，随机休眠一段时间，然后释放 PID。我有三门课；PID 类、Thread 类和驱动程序。我在驱动程序中有一个 PID 数组和一个线程数组。我已经设法将 PID 分配给数组中的每个 Thread 对象，但最后我总是得到一个 java.lang.NullPointerException。这是代码：

    public class PID {

    private int pid;                    // Unique process identifier
    private boolean availability;       // Used to determine PID's availability--1 for available, 0 for unavailable

    public PID() {};                    // Empty constructor for PID object

    public PID(int p, boolean a) {      // Constructor for PID object with parameters
        pid = p;
        availability = a;
    };

    public void setPID(int pid) {                           // Sets PID's value
        this.pid = pid;
    }

    public void setAvailability(boolean availability) {     // Sets availability of PID
        this.availability = availability;
    }

    public int getPID() {                   // Gets array of PIDs
        return this.pid;
    }

    public boolean getAvailability() {
        return this.availability;
    }

    public void allocatePID(int pid) {      // Will allocate a PID and return PID
        this.setPID(pid);   
        this.setAvailability(false);
    }

    public void releasePID() {              // Will release PID to be available for use
        this.setAvailability(true);
    }
}

线程类

import java.util.*;

public class MyThread extends PID implements Runnable {

    public MyThread() {};   // Constructor for thread object                            

    public void run() {

    Random gen = new Random();                      // Generates random values
    int sleepTime;                                  // Sleep time
    sleepTime = gen.nextInt(60000 - 1000) + 1000;   // Generates random sleep time between 1 and 60 seconds (1000 ms and 60000 ms)

    try {   
        System.out.println("This thread will sleep for " + sleepTime + " seconds.");
        Thread.sleep(sleepTime);
    } catch (Exception e) {
            System.out.println(e);
        } 
        System.out.println("The thread has been terminated");
    }

}

和司机

 public class PID_Driver {

    public static void main (String[] args)
    {
        Random gen = new Random();          // Will generate a random numbers
        int randomInt;                      // Random integer values
        boolean randomBool;                 // Random boolean values

        final int NUM_OF_PIDS = 100;            // Constant number of PIDs
        final int NUM_OF_THREADS = 20;          // Constant number of threads

        int j = 0;

        PID[] pids = new PID[NUM_OF_PIDS ];         // Array of PID objects
        MyThread[] threads = new MyThread[NUM_OF_PIDS]; // Array of threads

        for (int i = 0; i < NUM_OF_PIDS ; i++) {                        
            pids[i] = new PID();                            // Creates a new PID object
            randomInt = gen.nextInt(5000 - 300) + 300;      // Generates a random integer value between 300 and 5000
            pids[i].setPID(randomInt);                      // Sets each PID value with random integer
            randomBool = gen.nextBoolean();                 // Generates a random boolean value
            pids[i].setAvailability(randomBool);            // Sets each availability status with a boolean value
        }

        for (int i = 0; i < NUM_OF_PIDS; i++) {
            System.out.printf("\n%-10s   ", "PID value ");
            System.out.printf("%8d", pids[i].getPID());
            System.out.printf("%8s", pids[i].getAvailability());
        }

        System.out.println();

        for (int i = 0; i < NUM_OF_THREADS; i++)
            threads[i] = new MyThread();                        // Creates new thread

        while (threads[NUM_OF_PIDS-1] == null) {
            for (int i = 0; i < NUM_OF_PIDS; i++) {
                    if ((pids[i].getAvailability())) {
                        threads[j].allocatePID(pids[i].getPID());
                        System.out.println("This thread has a PID value of " + threads[j].getPID() + " and its availability is now " + threads[j].getAvailability());
                        ++j;
                }
            }

        }
         // for (int i = 0; i < NUM_OF_THREADS; i++) {
            //threads[i].run();                             // Run the thread
//          threads[i].releasePID();                        // Release the thread

//      }

    }
    }

我知道这与我如何编写 for 循环以根据可用性将 PID 分配给线程有关。我什至尝试在（疯狂的）尝试中添加一个 while 循环条件，以在每个线程都被分配了一个 PID 后停止循环，但我没有成功。

编辑：这是堆栈跟踪：

Exception in thread "main" java.lang.NullPointerException
    at PID_Driver.main(PID_Driver.java:52)

所以基本上 NPE 出现在这一行：

threads[j].allocatePID(pids[i].getPID());
4

2 回答 2

4

根据您的代码，您创建了一个包含 100 个线程的数组：

MyThread[] threads = new MyThread[NUM_OF_PIDS]; // Array of threads

但是，您只初始化前 20 个：

for (int i = 0; i < NUM_OF_THREADS; i++)
    threads[i] = new MyThread();                        // Creates new thread

然后，稍后，您调用此方法：

threads[j].allocatePID(pids[i].getPID());

除非您对 j 执行其他我看不到的操作，使其保持在 0 <= j < 20 内，即 j=20 时，它会尝试在未初始化的对象上调用该方法，从而导致异常。

于 2013-06-10T19:29:43.243 回答
1

维克多是对的，当达到 20 时它总是会抛出 NPE。j如果你想threads[NUM_OF_PIDS-1]在你的 while 循环中去，那么你必须用新的threads[20]对象填充。threads[99]MyThread

否则，如果您只想确保所有线程都获得一个 PID，则将您的 while 循环条件更改为：

while (threads[NUM_OF_THREADS-1].getPID() == 0) {
    ...
}

我猜这是一个复制意大利面错误。这条线

MyThread[] threads = new MyThread[NUM_OF_PIDS]; // Array of threads

应该

MyThread[] threads = new MyThread[NUM_OF_THREADS]; // Array of threads
于 2013-06-10T19:27:55.140 回答