Java wait()/join()：为什么这不会死锁？

Question

给出以下 Java 代码：

public class Test {

    static private class MyThread extends Thread {
        private boolean mustShutdown = false;

        @Override
        public synchronized void run() {
            // loop and do nothing, just wait until we must shut down
            while (!mustShutdown) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    System.out.println("Exception on wait()");
                }
            }
        }

        public synchronized void shutdown() throws InterruptedException {
            // set flag for termination, notify the thread and wait for it to die
            mustShutdown = true;
            notify();
            join(); // lock still being held here, due to 'synchronized'
        }
    }

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();

        try {
            Thread.sleep(1000);
            mt.shutdown();
        } catch (InterruptedException e) {
            System.out.println("Exception in main()");
        }
    }
}

运行此代码将等待一秒钟，然后正确退出。但这对我来说是出乎意料的，我预计这里会发生僵局。

我的推理如下：新创建的MyThread将执行run()，它被声明为“synchronized”，这样它就可以调用wait()并安全地读取“mustShutdown”；在 wait() 调用期间，锁被释放并在返回时重新获取，如 wait() 文档中所述。一秒钟后，主线程执行 shutdown()，它再次同步，以便在其他线程读取 MustShutdown 的同时不会访问 MustShutdown。然后它通过notify()唤醒另一个线程并通过join()等待其完成。

但在我看来，另一个线程不可能从 wait() 返回，因为它需要在返回之前重新获取线程对象上的锁。它不能这样做，因为 shutdown() 在 join() 内部仍然持有锁。为什么它仍然可以正常工作并退出？

Answer 1

join()方法内部调用wait()，这将导致释放(Thread对象的)锁。

请参阅下面的 join() 代码：

public final synchronized void join(long millis) 
    throws InterruptedException {
    ....
    if (millis == 0) {
       while (isAlive()) {
         wait(0);  //ends up releasing lock
       }
    }
    ....
}

您的代码看到此内容而不是一般情况下看到的原因：：您的代码看到此内容而不是一般情况下看不到的原因是因为 join()方法 waits() 在 Thread 对象 本身上，从而放弃对 Thread 对象本身的锁定，并且由于您的 run() 方法也在同一个 Thread 对象上同步，因此您会看到这种意想不到的情况。

Answer 2

Thread.join 的实现使用 wait，它会释放其锁，这就是为什么它不会阻止其他线程获取锁。

下面是对该示例中所发生情况的逐步描述：

在 main 方法中启动 MyThread 线程会导致一个新线程执行 MyThread run 方法。主线程休眠一整秒，为新线程提供充足的时间来启动并获取 MyThread 对象上的锁。

然后新线程可以进入 wait 方法并释放其锁。此时新线程进入休眠状态，在被唤醒之前不会再次尝试获取锁。线程尚未从等待方法返回。

此时主线程从睡眠中醒来并调用MyThread对象的shutdown。获取锁没有问题，因为新线程一旦开始等待就释放它。主线程现在调用notify。进入join方法，主线程检查新线程是否还活着，然后等待，释放锁。

一旦主线程释放锁，通知就会发生。由于主线程调用notify时新线程处于锁的等待集中，因此新线程收到通知并被唤醒。它可以获取锁，离开wait方法，执行完run方法，最后释放锁。

新线程的终止会导致所有等待其锁的线程接收通知。这会唤醒主线程，它可以获得锁并检查新线程是否已死亡，然后退出 join 方法并完成执行。

/**
 * Waits at most <code>millis</code> milliseconds for this thread to 
 * die. A timeout of <code>0</code> means to wait forever. 
 *
 * @param      millis   the time to wait in milliseconds.
 * @exception  InterruptedException if any thread has interrupted
 *             the current thread.  The <i>interrupted status</i> of the
 *             current thread is cleared when this exception is thrown.
 */
public final synchronized void join(long millis) 
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;

if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
}

if (millis == 0) {
    while (isAlive()) {
    wait(0);
    }
} else {
    while (isAlive()) {
    long delay = millis - now;
    if (delay <= 0) {
        break;
    }
    wait(delay);
    now = System.currentTimeMillis() - base;
    }
}
}

Answer 3

为了补充其他答案：我在 API 文档中没有看到提及 join() 释放任何锁，因此这种行为实际上是特定于实现的。

从中吸取教训：

• 不要子类 Thread，而是使用传递给线程对象的 Runnable 实现。
• 不要同步/等待/通知您不“拥有”的对象，例如您不知道还有谁可以同步/等待/通知它。