14.8. Inter-thread Communication

Threads can communicate using wait(), notify(), and notifyAll() methods from the Object class.

Inter-thread communication is essential when multiple threads need to coordinate their actions. Java provides three primary methods—wait(), notify(), and notifyAll()—that help facilitate this communication. The wait() method puts the current thread into a waiting state until another thread invokes notify() on the same object's monitor. The notify() method wakes one of the waiting threads, whereas notifyAll() wakes all waiting threads.

Imagine a restaurant where you place an order and wait at your table (using wait()). The waiter (another thread) comes to notify you that your food is ready (using notify()), or if there are several tables waiting, the waiter might announce that all the orders are ready (using notifyAll()). This parallels how threads wait for and notify each other about events in a program.

Example: synchronized(obj) { obj.wait(); // thread waits }

The wait() method is called inside a synchronized block and causes the calling thread to pause execution until another thread calls notify() or notifyAll() on the same object. This is crucial to prevent a thread from consuming resources while it awaits a signal from another thread. When the waiting thread is signaled, it becomes runnable again.

Think of a traffic light. A car (the thread) stops at a red light (calls wait()). It cannot move until the light turns green (notify method is called). Once the light turns green, the car can proceed again.

Example: synchronized(obj) { obj.notify(); // wakes one waiting thread }

The notify() method is also called within a synchronized block and wakes up one thread that is waiting on the same object's monitor. It's essential to use this method effectively for thread coordination; only the waiting thread can proceed, and the rest will remain in a waiting state until they are notified.

Consider a teacher in a classroom. When the teacher raises their hand (calls notify()), one student who has been waiting to answer raises their hand and is allowed to speak (is awakened from waiting). The other students still wait until it’s their turn.

This is used in producer-consumer problems, thread coordination, etc.

notifyAll() is used when all waiting threads should be awakened. Like notify(), it must be called within a synchronized block. This method is helpful in scenarios like the producer-consumer problem, where multiple threads may need to consume signals regarding resource availability. When invoked, all threads waiting on the object's monitor are notified and can compete to execute.

Imagine a classroom with several students waiting to answer questions (threads). When the teacher announces a quiz is over (calls notifyAll()), all the students can raise their hands to discuss answers, rather than just a single student. This coordination helps manage the interaction of many threads waiting for an opportunity to execute.

--