Question

According to a colleague, JVM does not guarantee that when calling “notify” on an object, the correct “wait” will be notified at that time. He says there can be a case when a previous notify which is not valid anymore is delivered at an invalid time.

Is this true? If so, how/why is this, and what use is the wait/notify mechanism if you cannot assume something as basic as this will work?

Answer 1

For java.lang.Object.notify, The Javadoc says:

Wakes up a single thread that is waiting on this object’s monitor. If
any threads are waiting on this object, one of them is chosen to be
awakened. The choice is arbitrary and occurs at the discretion of the
implementation. A thread waits on an object’s monitor by calling one
of the wait methods.

Here is a pattern to wait for a particular condition:

synchronized( lock ) {
   while( conditionEvaluation( data )) {
      lock.wait();
   }
}

The counterpart should use java.lang.Object.notifyAll() to ensure the vivacity of the application. Even if today, it’s only one waiter, after many evolutions of the software, it may be several waiters in the future, so notifyAll() is more robust than notify().