Inter-Thread Communication in Java

Inter-thread communication in Java lets one thread wait until another thread tells it that something has happened, such as "the data is ready". It uses three methods of the Object class: wait(), notify() and notifyAll(). A thread calls wait() to pause and release the lock; another thread changes the shared state and calls notify() or notifyAll() to wake the waiters. All three must be called inside a synchronized block on the same object. In this lesson, you will learn the rules and the correct pattern.

Methods

All three are final methods of Object, and all must be called while holding that object's lock; otherwise they throw IllegalMonitorStateException.

The Correct Pattern

// waiting side
synchronized (lock) {
    while (!condition) {
        lock.wait();
    }
    // condition is true: do the work
}
 
// signaling side
synchronized (lock) {
    condition = true;
    lock.notifyAll();
}

Always wait in a while loop that rechecks the condition: a thread can wake up without the condition being true (a spurious wakeup, or another thread got there first).

Example: Waiting Until the Report Is Ready

Let's see an example where one thread waits until another has prepared a report.

public class ReadySignal {
    private final Object lock = new Object();
    private String report;
 
    void waitForReport() throws InterruptedException {
        synchronized (lock) {
            while (report == null) {
                System.out.println("Advitha waits for the report");
                lock.wait();
            }
            System.out.println("Advitha reads: " + report);
        }
    }
 
    void publish(String text) {
        synchronized (lock) {
            report = text;
            System.out.println("Navika publishes the report");
            lock.notifyAll();
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        ReadySignal r = new ReadySignal();
        Thread reader = new Thread(() -> {
            try {
                r.waitForReport();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        reader.start();
        Thread.sleep(200);
        r.publish("Marks: 91, 78, 85");
        reader.join();
    }
}

Advitha waits for the report
Navika publishes the report
Advitha reads: Marks: 91, 78, 85

Explanation: The reader finds report is null and calls wait(), which releases the lock so the publisher can enter. The publisher sets the report and calls notifyAll(). The reader wakes, takes the lock back, rechecks the while condition, finds the report, and reads it.

notify() vs notifyAll()

Common Mistakes

Calling wait() outside synchronized. It throws IllegalMonitorStateException.

Using if instead of while around wait(). A spurious wakeup lets the thread continue with the condition still false.

Calling notify() before the waiter starts waiting, with no state flag. The signal is lost; always change a condition variable before notifying.

Interview Corner

Practice

1. Easy: Write a Mailbox with put(String) and take() that hold at most one message, using wait and notifyAll.
2. Harder: Make three threads print "1", "2", "3" in that order, repeated five times, coordinating with a shared turn counter and wait/notifyAll.

Key Takeaways