Page History

The Object.wait() method is used to temporarily cede possession of a lock so that another thread that is requesting thread the lock can proceed. It must always be used inside a synchronized block or method. To let make the waiting thread resume, the requesting thread must notify() it. Furthermore, the wait() method should be invoked in a loop that checks if a condition predicate holds. Note that a condition predicate is not the same as the condition expression in the loop. For example, the condition predicate for removing an element from a vector is !isEmpty() whereas the condition expression for the while loop condition is isEmpty(). The correct way to invoke wait() when the vector is empty is shown below.

public void consumeElement() {
  synchronized (vector) {
    while (vector.isEmpty()) {
      objectvector.wait(); 
    }

    // Consume when condition holds
  }
}

The notification mechanism notifies the waiting thread and lets it check its condition predicate. The invocation of notify() or notifyAll() in another thread cannot precisely determine which waiting thread must will be resumed. A condition predicate statement is used provided so that only the correct thread resumes will resume when it receives a notification. A condition predicate also helps when a thread is required to block until a condition becomes true, for instance, when it should not proceed without reading some data from an input stream.

...

To guarantee _safety_, the {{while}} loop condition must be tested even after invoking {{wait()}}. While {{wait()}} is meant to block indefinitely until a notification is received, this practice is recommended because: it should still be encased within a loop \[[Bloch 01|AA. Java References#Bloch 01]\], to prevent the following vulnerabilities:

• Thread in the middle: A third thread can acquire the lock on the shared object during the interval between a notification being sent and the receiving thread resuming execution. This thread can change the state of the object, leaving it inconsistent. This is a time of check, time of use (TOCTOU) condition.
• Malicious notificationsnotification: There is no guarantee that a random notification will not be received when the condition predicate is false. This means that the invocation of wait() may be nullified by the notification.
• Mis-delivered notification: Sometimes on receipt of a notifyAll() signal, an unrelated thread can start executing and it is possible for its condition predicate to be true. Consequently, it may resume execution whilst it was required to remain dormant.

• Wiki Markup
  Spurious wakeups: Certain JVM implementations are vulnerable to _spurious wakeups_ that result in waiting threads waking up even without a notification \[[API 06|AA. Java References#API 06]\].

...

Newer code should use the java.util.concurrent concurrency utilities as opposed to the wait/notify mechanism, however, legacy code may require these methodsthe wait/notify mechanism.

Noncompliant Code Example

...

synchronized (object) {
  if (<condition does not hold>) {
    object.wait();
  }
  // Proceed when condition holds
}

...

synchronized (object) {
  while (<condition does not hold>) {
    object.wait(); 
  }

  // Proceed when condition holds
}

...