java:wait（）方法即使在调用notifyAll（）之后仍保持等待

Question

考虑以下代码

public class ThreadTest1
{
private static final long startTime = System.currentTimeMillis();

    public static void main(String args[])
    {
        Thread ct = new Thread(new ChildThread());
        ThreadTest1.print("starting child threads in MAIN");
        ct.start();
        synchronized(ct)
        {
            try
            {

            ThreadTest1.print("about to start wait() in MAIN");
            ct.wait();
            ThreadTest1.print("after wait() in MAIN");
            }
            catch(Exception e)
            {
            ThreadTest1.print("Exception in MAIN");
            }
        }
    }

    public static void print(String s)
    {
    System.out.println("Millisecond : "+(System.currentTimeMillis()-ThreadTest1.startTime)+"\t: "+s);
    }
}

class ChildThread implements Runnable
{
    public void run()
    {
        synchronized(this)
        {

        try
        {
        ThreadTest1.print("before thread notifyAll in CHILD");
        notifyAll();
        ThreadTest1.print("notifyAll over, sleep starts in CHILD");
        Thread.sleep(10000);
        ThreadTest1.print("after thread sleep in CHILD");

        }
        catch(Exception e)
        {
        ThreadTest1.print("Exception in CHILD");
        }
        ThreadTest1.print("End of run method in CHILD");
        }
    }
}

结果如下：

Millisecond : 12        : starting child threads in MAIN
Millisecond : 13        : about to start wait() in MAIN
Millisecond : 13        : before thread notifyAll in CHILD
Millisecond : 13        : notifyAll over, sleep starts in CHILD
Millisecond : 10015     : after thread sleep in CHILD
Millisecond : 10015     : End of run method in CHILD
Millisecond : 10016     : after wait() in MAIN

notifyAll（）在13毫秒时被调用。但是，控件仅在10016毫秒时退出等待（）。

从上面给出的代码中可以看出，在进行了通知（）调用之后，等待（）调用似乎没有立即结束。

但是，包括Java API在内的所有文档都指定，调用wait（）的方法应该在notify（）调用之后立即获得锁。

如果在调用通知（）时等待（）不会结束，那么对通知（）的需求就会变得无效，因为即使没有调用通知（），调用等待（）的方法也会在新线程的run方法结束时自动获得控制。

如果我在这里犯了一个错误，等待有人抛出一些光。

Answer 1

这里有两个问题：

>

wait和notify在相同对象上调用，并在相同对象上同步的同步块内调用。你的不一样。一个位于名为ct的thead上，另一个位于ChildThread类型的Runnable上。

在等待之前，您正在呼叫start。很可能在主线程开始等待之前调用notify。所以你可能会错过通知。在修复点1后，尝试调整代码，以使等待和通知间隔最小化。

Answer 2

根据其他答案的建议，这里是一个可行的实现。请注意，我还将睡眠移到了synchronized块之外。通常，同步块应尽可能短。。。

public class ThreadTest {

    private static final long startTime = System.currentTimeMillis();

    public static void main(String args[]) {
        Thread ct = new ChildThread();
        ThreadTest.print("starting child threads in MAIN");
        ct.start();
        try {
            ThreadTest.print("about to start wait() in MAIN");
            synchronized (ct) {
                ct.wait();
            }
            ThreadTest.print("after wait() in MAIN");
        } catch (Exception e) {
            ThreadTest.print("Exception in MAIN");
        }
    }

    public static void print(String s) {
        System.out.println("Millisecond : " + (System.currentTimeMillis() - ThreadTest.startTime) + "\t: " + s);
    }

    private static final class ChildThread extends Thread {
        public void run() {
            try {
                ThreadTest.print("before thread notifyAll in CHILD");
                synchronized (this) {
                    notifyAll();
                }
                ThreadTest.print("notifyAll over, sleep starts in CHILD");
                Thread.sleep(1000);
                ThreadTest.print("after thread sleep in CHILD");

            } catch (Exception e) {
                ThreadTest.print("Exception in CHILD");
            }
            ThreadTest.print("End of run method in CHILD");
        }
    }
}

Answer 3

问题是您正在通知并等待不同的对象。您可以在线程上wait（）并在run（）方法中调用this。。。这是一个子线程。

您将ChildThread类命名错误，这一事实掩盖了这一点。这个名称意味着它是一个线程子类，但实际上它是一个可运行的子类。