使用 wait 和 notifyAll 时 Java 程序冻结

Question

我正试图深入了解 wait 和 notifyAll 是如何工作的，并且遇到了障碍。

该程序下载一个长文本文档，启动多个线程来计算字符数，然后输出总计数。

我正在使用 wait 和 notifyAll 来控制线程执行，以便它们按字母顺序完成。这是代码。接下来我会解释这个问题。

public class Test {

    public static void main(String[] args) {
  //code that reads in the data

LongTask a = new LongTask(buffer, 'a', "Thread_a", 0);
    a.start();

LongTask b = new LongTask(buffer, 'b', "Thread_b", 1);
    b.start();

//Repeat code for all other characters

a.join();

System.out.println("Alphabet count is: " + SharedResults.getResults());

LongTask 类包含构造函数和 run()

public class LongTask extends Thread {
//Instance variables created here

//LongTask constructor
public LongTask (StringBuffer buffer, char target, String name, int turn)
{
    super(name);
    this.sharedData = sharedData;
    inputData = buffer;
    this.target = target;   
    this.turn = turn;
}


//Run method iterates through input data and counts matching characters, 
//then calls addToResults
public synchronized void run()
{
    //Thread t = Thread.currentThread();
    String name = this.getName();
    int runTurn = this.turn;
    System.out.println(name + " running - Turn " + runTurn);
    Integer count = 0;
    for (int i = 0; i < inputData.length(); i++) {
        if (inputData.charAt(i) == target) {
        count ++;   
        }
    }
    ResultsEntry newResult = new ResultsEntry(count, target);
    SharedResults.addToResults(newResult, turn);
    }
}

SharedResults 类将结果添加到 Array。 addToResults 方法执行此操作并控制同步。

public class SharedResults extends Thread{
//Code that creates array
//Code for SharedResults constructor

public synchronized static void addToResults(ResultsEntry newResult, int turn)
{   
    Integer resultsCount =  newResult.getCount();
    char resultsTarget = newResult.getTarget();
    Thread t = Thread.currentThread();

    /*
     * Turn number is compared to the size of the results array to control the
     * order of execution. 
     */
    while (turn != results.size()){ 
        try {
            System.out.println("Wait printout");
            t.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    } 
    System.out.println(t.getName() + " is adding " + newResult);
    SharedResults input = new SharedResults(resultsCount, resultsTarget);
    System.out.println("Cumulative Results are " + results);    
    t.notifyAll();      
    }

这是我在 Debug 中观看此步骤时看到的内容。 -Input 执行，所有 LongTask 线程启动

（Thread_a 应该是第一个执行 addToResults 的线程）

- 一些线程（不是 Thread_a）在 addToResults 的 while 评估中运行，并且不继续

-Thread_a 达到 while 评估并完全执行。 （现在应该轮到Thread_b了）

-Thread_e 执行“等待打印输出”（只是一个调试功能，告诉我线程何时等待），然后程序挂起。

在我看来，我没有正确设置等待。在我添加到 sysout 之前，该程序实际上（或看起来）正常工作。有什么想法吗？

Answer 1

回答我自己的问题，

this thread. 对此进行了报道

问题在于 notifyAll() 通知所有 该对象的 正在等待的线程。因为我在每个线程上调用 wait()，来自另一个线程的 notifyAll() 没有通知任何其他线程。

根据链接帖子的建议，我创建了一个静态同步对象，并在该对象上调用了等待和通知方法。生成的代码如下所示： private static final Object LOCK = new Object();

public static void addToResults(ResultsEntry newResult, int turn)
{   
    Integer resultsCount =  newResult.getCount();
    char resultsTarget = newResult.getTarget();
    Thread thread = Thread.currentThread();

    /*
     * Turn number is compared to the size of the results array to control the
     * order of execution. 
     */
    synchronized (LOCK){
        while (turn != results.size()){
            try {
                System.out.println(thread.getName() + " is waiting");
                LOCK.wait();
                } catch (InterruptedException e) {}
        }
            System.out.println(thread.getName() + " is adding " + newResult);
            SharedResults input = new SharedResults(resultsCount, resultsTarget);
            System.out.println("Cumulative Results are " + results);    
            LOCK.notifyAll();   
        }
        }

感谢所有评论的人！