while(condition) { Object.wait() } idiom

Question

I know, that we use this idiom for waiting for notification to handle spurious wakeups:

synchronized (obj) {
    while(somecond)
        obj.wait();
}

If a spurious wake up arises, we'll just check the state and return back to waiting.

But, consider the situation:

1. We begin waiting, and obj.wait() releases lock on obj.
2. Waiting thread is spuriously notified by OS
3. We return to checking condition (with obj lock released due to wait)
4. obj.notify() is called right in that moment.

Yes, condition checking is extremely fast and chances, that we can be in condition checking and not in obj.wait(), are negligibly small. In that case we can loose obj.notify() call.

Am I misunderstanding something, or we really can loose notification using this pattern?

Answer 1

Another thread needs the lock on obj to be able to call obj.notify(). And it can't have it if your thread is in the while loop not waiting, since your thread also needs the lock on obj to be in the while loop.

Answer 2

The call to obj.wait() will not return until an obj.notify() has been called. However, you might fail to respond to an obj.notify() if another thread is also waiting and the system decides to notify that thread instead. If you want to avoid that, you can use obj.notifyAll(). If only one thread is waiting, you cannot lose the notification with this pattern.

Note that the other thread cannot call obj.notify() unless it holds the lock. If this thread is busy checking the condition, then it has the lock and the other thread cannot issue a notification. The synchronized block is essential to the operation.