java - 实现Runnable而不是扩展Thread时的不同行为

Question

所以这是代码。
基本上，如果我们将ReadCalculation和Calculator类更改为扩展Thread而不是实现Runnable，我们将需要实例化这些类并将它们传递给新的线程对象，或者只对它们调用start()。

Calculator calc = new Calculator();
new ReadCalculation(calc).start();
new ReadCalculation(calc).start();
calc.start();

到目前为止，没有什么特别的。但是，当您执行Runnable实现而不是扩展Thread类时，执行此小程序时，您的线程很有可能会被阻塞“正在等待计算...”。

如果我们扩展Thread类而不是实现Runnable，那么行为是正确的，没有任何竞争条件的迹象。
任何想法可能是这种行为的根源？

public class NotifyAllAndWait {

public static void main(String[] args) {

        Calculator calc = new Calculator();
        Thread th01 = new Thread(new ReadCalculation(calc));
        th01.start();
        Thread th02 = new Thread(new ReadCalculation(calc));
        th02.start();

        Thread calcThread = new Thread(calc);
        calcThread.start();
    }
}

class ReadCalculation implements Runnable {

    private Calculator calc = null;
    ReadCalculation(Calculator calc) {
        this.calc = calc;
    }

    @Override
    public void run() {
        synchronized (calc) {
            try {
                System.out.println(Thread.currentThread().getName() + " Waiting for calculation...");
                calc.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " Total: " + calc.getTotal());
        }
    }
}

class Calculator implements Runnable {
    private int total = 0;
    @Override
    public void run() {
        synchronized(this) {
            System.out.println(Thread.currentThread().getName() + " RUNNING CALCULATION!");
            for(int i = 0; i < 100; i = i + 2){
                total = total + i;
            }
            notifyAll();
        }
    }
    public int getTotal() {
        return total;
    }
}

Answer 1

至少在implements Runnable版本中，您没有采取任何措施来确保ReadCalculation线程在wait()线程进入其Calculator块之前到达synchronized。如果Calculator线程首先进入其synchronized块，则它将在notifyAll()线程调用ReadCalculation之前调用wait()。如果发生这种情况，则notifyAll()是空操作，并且ReadCalculation线程将永远等待。 (这是因为notifyAll()只关心已经在对象上等待的线程；它没有在该对象上设置任何类型的指示符，而该指示符可以被后续对wait()的调用检测到。)

要解决此问题，您可以在Calculator中添加一个可用于检查完成情况的属性，并且仅在未完成wait()时才调用Calculator:

if(! calc.isCalculationDone()) {
    calc.wait();
}

(请注意，为了完全避免争用情况，将整个 if -statement放在 synchronized块内是很重要的，并且 Calculator在调用 synchronized的 notifyAll()块内设置了此属性。您知道为什么吗？)

(顺便说一句，彼得·劳里(Peter Lawrey)的评论“一个线程可以在其他线程甚至没有开始之前就轻松地进行100次迭代”的说法极具误导性，因为在您的程序中，所有100次迭代都在 Calculator进入其 synchronized块之后发生。当 ReadCalculation在其 synchronized块中时，线程被阻止进入其 calc.wait()块并调用 Calculator，这是1次迭代，100次迭代还是1,000,000次迭代无关紧要，除非它具有有趣的优化效果，可以改变运行时间。之前的程序。)

您尚未发布整个 synchronized版本，但是如果我正确理解它的外观，那么它实际上仍然具有相同的竞争条件。但是，种族条件的本质是微小的变化会严重影响不当行为的可能性。即使似乎从未真正发生过错误，您仍然需要修复竞争条件，因为几乎可以肯定的是，如果您运行该程序足够的时间，偶尔也会出现错误。

对于为什么一种方式比另一种方式更容易发生不当行为，我没有很好的解释。但是，正如上面的user1643723所评论的那样， extends Thread方法意味着除您之外的其他许多代码也可能会锁定在 extends Thread实例上；这很可能会产生某种效果。但老实说，我不值得过多担心种族状况可能导致或多或少引起不当行为的原因。我们必须修复它，无论故事结局如何。

顺便:

上面，我使用了Calculator；但是实际上最好的做法是始终将对if(! calc.isCalculationDone())的调用包装在适当的wait() -loop中，因此，实际上您应该编写while。造成这种情况的主要原因有两个:

在平凡的程序中，您不一定知道为什么调用while(! calc.isCalculationDone())，或者即使您这样做，也不知道在等待线程实际唤醒并重新获得notifyAll() -lock时，该原因是否仍然适用。如果您使用synchronized结构来表达notify()的想法，则不仅仅可以编写wait()并尝试确保没有东西会导致它返回，这使您可以更轻松地推断while(not_ready_to_proceed()) { wait(); }/wait_until_ready_to_proceed()交互的正确性。还没准备好。

在某些操作系统上，向进程发送信号将唤醒wait() -ing的所有线程。这称为伪唤醒。有关更多信息，请参见"Do spurious wakeups actually happen?"。因此，即使没有其他名为wait()或notify()的线程，一个线程也可能被唤醒。

notifyAll()中的for -loop不应位于Calculator.run()块中，因为它不需要任何同步，因此不需要争用。在您的小型程序中，它实际上没有任何区别(因为其他线程在那一点上实际上都没有任何关系)，但是最佳实践始终是尽量减少synchronized块内的代码量。