Wait/Notify的奇怪Java行为

Question

我发现了Java并发的奇怪行为。请参阅下面的下一段代码：

    public class Test {
        static CountDownLatch latch = new CountDownLatch(1);
        public static void main(String[] args) throws UnsupportedEncodingException, InterruptedException {
            final Thread t = new MyThread();
            t.start();
            synchronized (t) {
                latch.countDown();
                System.out.println("got to sleep");
                t.wait();
                System.out.println("wake up");
            }
        }

        static class MyThread extends Thread {
            @Override
            public void run() {
                try {
                    latch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (this) {
                    System.out.println("inside run");
    //                notifyAll();
                }
            }
        }
    }

在我看来，这段代码应该挂起并永远等待，但是在控制台中的next out没有任何问题地完成了代码：

got to sleep
inside run
wake up

我试图找到一些关于如果线程死了通知锁的信息，但缺乏。我也没有在Java规范中找到任何信息。

但是如果我试图锁定其他对象（而不是thread对象），就会像我预期的那样工作得很好。

Answer 1

正如Jon Skeet所写的那样，在线程对象上同步是个坏主意，使用另一个：

public class Test {
    static CountDownLatch latch = new CountDownLatch(1);
    static final Object sync = new Object();

    public static void main(String[] args) throws UnsupportedEncodingException, InterruptedException {
        final Thread t = new MyThread();
        t.start();
        synchronized (sync) {
            latch.countDown();
            System.out.println("got to sleep");
            sync.wait();
            System.out.println("wake up");
        }
    }
}

static class MyThread extends Thread {
    @Override
    public void run() {
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (sync) {
            System.out.println("inside run");
            //sync.notifyAll();
        }
    }
}

现在,在取消对sync.notifyAll（）的注释之前,这段代码将永远不会结束；

Answer 2

这是因为您正在等待thread实例。thread在内部使用wait/notify/notifyall，所以您自己也不应该这样做--您会混淆thread，而thread也会混淆您。特别是，当线程退出时，它调用this.notifyAll()。

从thread.join的文档中可以看到：

此实现使用This.wait调用的循环，该循环以This.isalive为条件。当线程终止时，将调用this.notifyall方法。建议应用程序不要在thread实例上使用wait、notify或notifyall。

通常情况下，尝试锁定并等待其他任何东西都无法与之交互的对象。这样，您就可以对对象上存在的与并发相关的操作进行推理，因为它们是非常有限的。只要任意代码能够在对象上同步（并调用wait/notify等），就很难证明您的代码是正确的。这就是为什么你会经常看到这样的东西：

public class Foo {
    private final Object lock = new Object();

    ... code which uses synchronized(lock) ...
}