Может ли Thread выполнять дальнейшие инструкции после вызова target.wait (), без вызова target.notify ()? [Дубликат]

У вас есть вложенные синхронизированные {} конструкции в двух местах. Эти конструкции кажутся чем-то странным: нить не реагирует на уведомления вообще и только возобновляется, когда ThreadB (b) завершается. Удалить это:

public class JavaApplication2 {
    public static void main(String[] args) {
        ThreadB b = new ThreadB();
        b.start();
        try {
            System.out.println(" ### Waiting for notify");
            synchronized (b) {
                b.wait();
            }
            System.out.println(" ### Notified");
        } catch (InterruptedException e) {
        }
        System.out.println("### Total is: " + b.total);
    }
}

class ThreadB extends Thread {
    int total;

    @Override
    public void run() {
        total += 1;
        System.out.println(" *** Ready to notify in 5 secs");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
        }
        System.out.println(" *** Notification sent");
        synchronized (this) {
            notify();
        }
        System.out.println(" *** 5 sec post notification");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
        }
        System.out.println(" *** ThreadB exits");
    }
}

Возможно, что код выше работает корректно: при уведомлении () текущий основной поток возобновляется через 5 секунд и до того, как мы увидим сообщение, которое ThreadB завершает. С notify () закомментировал, что основной поток возобновляется через 10 секунд и после сообщения о прекращении ThreadB, потому что notify () вызывается anywhay из другого кода. Марко Тополник объясняет, почему и откуда происходит этот вызов «за сценой» notify ().

Вы не можете зависеть от того, не возвращаетесь ли вы от ожидания до уведомления: «возможны прерывания и ложные пробуждения». В общем случае вы должны завернуть вызов ожидания в цикле, пока поток должен продолжать ожидание.

Метод notifyAll() вызывается для объекта Thread конечной нити. Этот факт странно задокументирован в описании Thread.join со следующим предложением:

По мере того, как поток завершается, этот метод this.notifyAll вызывается. Рекомендуется, чтобы приложения не использовали wait, notify или notifyAll для экземпляров Thread.

Таким образом, если вы явно не читаете описание join, которое вы не обязательно придется, вы не узнаете причину странного поведения.

Если вы попытаетесь синхронизировать свой код с любым другим объектом, который ThreadB вы обнаружите, что он никогда не заканчивается. Это потому, что есть скрытый вызов notify.

Хотя я не знаю нигде, что это указано, Thread уведомляет себя, когда он заканчивается. Это подразумевается в способе реализации метода join. Это код для join:

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;
        }
    }
}

(Из исходного кода JDK7)

Как вы можете видеть, вызовы wait имеют смысл, если где-то там является вызовом notify, который вызывается после окончания потока. Тот же вызов notify позволяет завершить вашу программу.

Я делал то же тестирование на операции wait / notify при чтении OCP SE 7, хороший catch. Я думаю, мы должны позволить автору объяснить.