Inter-Thread Communication (ITC)

Inter-Thread Communication (ITC) in Java is a powerful concept that allows multiple threads to communicate with each other in a controlled and synchronized way.

It is mainly achieved using three important methods:

These methods help threads pause, resume, and coordinate execution while working on shared resources.

Why Inter-Thread Communication Is Needed

In multithreaded applications, threads often share common data.

If threads access this data without coordination, it may cause:

• Race conditions
• Data inconsistency
• Unexpected program behavior
• Wastage of CPU due to busy waiting

Inter-thread communication solves these problems by allowing threads to wait for a condition and get notified when that condition is fulfilled.

Where Do wait(), notify() and notifyAll() Come From?

All three methods belong to the Object class, not the Thread class.

👉 This is because every object in Java can be used as a lock, and threads communicate using that object’s monitor.

Important Rule :

These methods must always be called inside a synchronized block or synchronized method, otherwise JVM throws IllegalMonitorStateException.

Key Methods for Inter-Thread Communication

These methods belong to the Object class:

1. wait() Method

The wait() method tells the current thread to pause execution and go into a waiting state until another thread notifies it.

What happens internally when wait() is called?

When a thread calls wait():

1. The thread releases the lock of the object
2. The thread enters the waiting state
3. Other threads are allowed to acquire the lock
4. The waiting thread resumes only when:
   • notify() is called
   • notifyAll() is called
   • or the thread is interrupted

Syntax of wait()

synchronized (object) {
    object.wait();
}

Example of wait()

classSharedData {
booleandataAvailable=false;

synchronizedvoidconsume()throws InterruptedException {
while (!dataAvailable) {
            System.out.println("Consumer waiting...");
            wait();// releases lock and waits
        }
        System.out.println("Consumer consumed data");
    }
}

Explanation

• Consumer checks condition
• If data is not available → it calls wait()
• Lock is released
• Consumer waits until producer notifies

Real-Life Analogy for wait()

Think of a student waiting outside the classroom.

The student leaves the door (lock) free and waits until the teacher calls him inside.

2. notify() Method

The notify() method wakes up exactly one thread that is waiting on the same object.

If multiple threads are waiting, only one thread is chosen randomly by the JVM scheduler.

Important Points about notify()

• Must be called inside a synchronized block
• Does not immediately release the lock
• The awakened thread runs only after the current thread exits the synchronized block

Syntax of notify()

synchronized (object) {
    object.notify();
}

Example of notify()

classSharedData {
booleandataAvailable=false;

synchronizedvoidproduce() {
        dataAvailable =true;
        System.out.println("Producer produced data");
        notify();// wakes one waiting thread
    }
}

Explanation

• Producer updates shared data
• Calls notify()
• One waiting consumer thread wakes up
• Consumer resumes after producer releases the lock

Real-Life Analogy for notify()

Imagine calling one person’s name from a waiting room.

Only that person gets up; others keep waiting.

3. notifyAll() Method

The notifyAll() method wakes up all threads waiting on the same object.

All awakened threads then compete for the lock, but only one thread gets it at a time.

When should notifyAll() be used?

• When multiple threads depend on the same condition
• When using complex logic with multiple consumers
• To avoid thread starvation or missed signals

Syntax of notifyAll()

synchronized (object) {
    object.notifyAll();
}

Example of notifyAll()

classSharedResource {

synchronizedvoidupdateResource() {
        System.out.println("Resource updated");
        notifyAll();// wakes all waiting threads
    }
}

Explanation

• Resource state changes
• All waiting threads are informed
• Threads check condition and proceed one by one

Real-Life Analogy for notifyAll()

Think of ringing a bell in a school.

All students hear it, but only one enters the classroom at a time.

How ITC Works

1. Producer Thread: Produces data and notifies the consumer.
2. Consumer Thread: Waits if no data is available, consumes it, and notifies the producer.
3. Synchronization: Ensures mutual exclusion while accessing shared resources.

Steps:

1. Thread calls wait() → goes to waiting state and releases lock.
2. Another thread modifies the resource and calls notify() / notifyAll().
3. Waiting thread wakes up → re-enters ready state, acquires lock → continues execution.

Example: Producer-Consumer Problem

classSharedBuffer {
privateint data;
privatebooleanavailable=false;

publicsynchronizedvoidproduce(int value)throws InterruptedException {
while (available) wait();// wait until data is consumed
        data = value;
        available =true;
        System.out.println("Produced: " + value);
        notify();// notify consumer
    }

publicsynchronizedintconsume()throws InterruptedException {
while (!available) wait();// wait until data is produced
        available =false;
        System.out.println("Consumed: " + data);
        notify();// notify producer
return data;
    }
}

publicclassProducerConsumerExample {
publicstaticvoidmain(String[] args) {
SharedBufferbuffer=newSharedBuffer();

Threadproducer=newThread(() -> {
for (inti=1; i <=5; i++) {
try { buffer.produce(i); }catch (InterruptedException e) {}
            }
        });

Threadconsumer=newThread(() -> {
for (inti=1; i <=5; i++) {
try { buffer.consume(); }catch (InterruptedException e) {}
            }
        });

        producer.start();
        consumer.start();
    }
}

Output Example:

Produced: 1
Consumed: 1
Produced: 2
Consumed: 2
...

Key Points

• wait() → releases lock and waits.
• notify() → wakes up one waiting thread.
• notifyAll() → wakes up all waiting threads.
• Always used inside synchronized blocks/methods.
• Avoids busy waiting, improves CPU efficiency, and prevents data inconsistency.

Summary

• ITC allows threads to coordinate access to shared resources.
• Key methods: wait(), notify(), notifyAll() (used with synchronized).
• Solves issues like race conditions and busy waiting.
• Commonly used in Producer-Consumer, Bounded Buffer, Thread Pools.
• Ensures safe, efficient, and predictable multithreaded execution.