如果在Thread上调用java wait（），则该方法也会在run（）方法终止时退出

Question

I'm puzzled with a particular use case of the wait() method.
According with javadoc, wait should end when one of the following condition happens:

• another thread invokes notify or notifyAll (ok, see javadoc for a detail on notify but this is not relevant for this question)
• another thread interrupts this (waiting) thread
• a timeout expires (if using the wait version with timeout)

In the case in which the object i'm waiting on is itself a Thread, it happens that the wait() exits even if no notify() has been called, and no one of the above conditions holds. But it happens when the Thread.run() method ends. While this behavior may make sense, shouldn't it be documented inside of Thread javadoc? I find it very confusing also because it overlaps with join() behavior.

This is my test code:

public static class WorkerThread extends Thread {

    @Override public void run() {

        try{
           System.out.println("WT: waiting 4 seconds");
           Thread.sleep(4000);

           synchronized (this) {
            notify();
           }

           System.out.println("WT: waiting for 4 seconds again");
           Thread.sleep(4000);
           System.out.println("WT: exiting");

        } catch (InterruptedException ignore) {
            ignore.printStackTrace();
        }

    }

}

public static void main (String [] args) throws InterruptedException {

    WorkerThread w = new WorkerThread();

    w.start();

    synchronized(w) {
        w.wait();
        System.out.println("MT: The object has been notified by the thread!");
    }

    synchronized(w) {

        w.wait(); //THIS FINISHES WITHOUT notify(), interrupt() OR TIMEOUT!

        System.out.println("MT: The thread has been notified again!");
    }

}

Answer 1

It is documented since Java 7, in the documentation of the join() method :

As a thread terminates the this.notifyAll method is invoked. It is recommended that applications not use wait, notify, or notifyAll on Thread instances.

Answer 2

It is a common anti-pattern to extend Thread directly. The problem is you can have all sorts of unintended consequences as Thread is a complex class. One thing it does is notify threads trying to join() the thread when it stops. This has the effect of notifying any thread waiting on that thread object.

A common Java puzzler is to miss use a class which extends Thread.

BTW While using wait()/notify() has been old school for more than 9 years now, you can still use them in rare situations. If you do you should change the state of something in the notify() block and wait for that state change when you wait(). This is because if you call notify before wait, it is lost and wait() can exist spuriously, even if you don't extend thread.

Answer 3

如果您想要可预测和可控制的等待/通知行为，请在线程和等待它的方法之间共享一个Object。