在同步块中使用wait（）方法时，JVM是否在等待notify（）时释放监视器？

Question

I have a thread that starts another thread which performs an action that will cause an event to fire after it runs. I need to capture that event (via an event listener) in the first thread and continue the rest of the work. My question is that while the first thread is waiting for the event listener to call notify() will it release the monitor? If not, how can I design this algorithm? Am I using the wait() and notify() methods correctly and for the correct lock (thread1)?

Here is how the code looks like:

public class Thread1 {
    public void run() {
        Thread thread1 = Thread.currentThread();
        EventListener listener = new EventListener(thread1);
        Performer performer = new Performer();
        performer.addOnPerformedListener(listener);

        synchronized(thread1) {
            performer.run();    // Launches thread 2
            thread1.wait();
        }
        ...
    }

    public class EventListener implements Performer.OnPerformedListener {
        private Thread thread;

        public EventListener(Thread thread) {
            this.thread = thread;
        }

        @Override
        public void onPerformed() {
            synchronized (thread) {
                thread.notify();
            }
        }
    }
}

Answer 1

This is close. It's hard to tell how close without the rest of the code though (in performer).

First thing, I recommend not holding the lock on the thread over the " performer.run() " call - if that's feasible. Keeping critical sections (code executed with locks held) as small as possible is a "best practice".

Second, I recommend using a condition flag set in the performer (if I'm understanding the code correctly) and performing the check inside the critical section before calling wait() - so that missed notification does not lead to a missed condition.

Here's psuedo-code:

THREAD1
* Initialize THREAD2
* Start THREAD2
* synchronized ( THREAD2 ) { while ( THREAD2.conditionNotMet() ) { THREAD2.wait(); } }

THREAD2
* Initialize "condition not met"
* Run
* On condition met, set "condition met", then synchronized ( THREAD2 ) { THREAD2.notifyAll(); }

Furthermore, if the condition may occur multiple times and the code waiting on the condition only wants to continue on newer occurrences, try a sequence number instead of just a "was condition met" (eg if ( myLastOccurrenceNumber < THREAD2.getLastOccurenceNumber ) { MET-CONDITION ) } else { WAIT } ).

Answer 2

The basic idea of what you're doing is right. As the Javadoc of the Object#wait() method states, it releases the monitor that you acquired using the synchronized statement while it waits:

The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up

However, there is a reason why it is not guaranteed to work correctly in every situation as you have implemented it, and the reason is that the wait call can also wake up through "interrupts and spurious wakeups". (It will work correctly in 99% of the cases as you have currently implemented, which makes it all the more tricky as this gives a false sense that it will always work)

As the Javadoc states:

As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:

 synchronized (obj) { while (<condition does not hold>) obj.wait(); ... // Perform action appropriate to condition } 

So you'll also need something to indicate the condition "performed" -the easiest way to do that is by creating a boolean field named performed that you set to true before calling notify in the onPerformed method.

The value of this flag will be seen correctly by thread1 because thread2 releases the monitor before thread1 acquires the same monitor, and this establishes a happens-before relationship as describes in the Java Memory Model specification.