Inter-Thread Communication

Inter-thread communication allows threads to coordinate work. The wait(), notify(), and notifyAll() methods of the Object class allow threads to yield locks and wait for changes.

API Contract and Guidelines

You must follow these rules when using these APIs:

• Synchronized Context: You can only call wait(), notify(), or notifyAll() on an object if you hold that object's monitor lock. Otherwise, the JVM throws an IllegalMonitorStateException.
• Loop Condition (Crucial): Always call wait() inside a while loop, never an if statement. This protects against spurious wakeups (where a thread wakes up without being notified) and race conditions where state changes before the thread resumes.
• State Transition: Calling wait() releases the lock and transitions the thread to the WAITING state. Calling notify() transitions one waiting thread to the BLOCKED state, waiting to acquire the lock when the caller releases it.

Code Walkthrough

Here is a complete, thread-safe implementation of a 1-capacity Bounded Buffer (Producer-Consumer).

public class SharedBuffer {
    private String data;
    private boolean empty = true;
public synchronized void produce(String item) throws InterruptedException {
        // Always check condition in a loop
        while (!empty) {
            wait(); // Releases lock, enters WAITING
        }
        data = item;
        empty = false;
        System.out.println("Produced: " + item);
        notifyAll(); // Wake up waiting consumers
    }
public synchronized String consume() throws InterruptedException {
        while (empty) {
            wait();
        }
        String item = data;
        empty = true;
        System.out.println("Consumed: " + item);
        notifyAll(); // Wake up waiting producers
        return item;
    }
}

Interview-Relevant Information