Inter Thread Communication In Java - All Methods Explained (+Codes)

18 mins read

In Java, threads are like independent workers executing tasks in parallel. Sometimes, these threads need to coordinate or share information to ensure tasks are completed in a synchronized and efficient way. This coordination is called inter-thread communication. Inter-thread communication allows threads to exchange messages or signals, enabling them to work together seamlessly.

Java provides built-in methods like wait(), notify(), and notifyAll() to facilitate this communication. In this article, we’ll explore what inter-thread communication is, why it’s important, and how to implement it in Java with simple examples to make the concepts clear.

Why Do Threads Need To Communicate?

Threads need to communicate to coordinate their actions when they share resources or depend on each other’s tasks. Without proper communication, threads might work independently, leading to issues like data inconsistency, resource conflicts, or missed dependencies.

Let’s explore some scenarios where thread communication becomes essential:

1. Producer-Consumer Problem: Imagine a factory with two types of workers:

• Producers: Create items and place them on a conveyor belt (shared resource).
• Consumers: Pick items from the conveyor belt and package them.

Here’s why communication is crucial:

• Synchronization: If producers place items faster than consumers can pick them, the conveyor might overflow. Similarly, if consumers try to pick items when the belt is empty, they’ll face delays.
• Avoiding Conflicts: Producers and consumers must ensure they don’t simultaneously access the same section of the belt, which could result in data corruption or operational errors.

2. Synchronization to Avoid Conflicts: Threads sharing resources, like memory or files, need to synchronize their access to prevent conflicts. For example:

• Banking System: Two threads handling a user’s transactions could simultaneously withdraw from the same account, leading to incorrect balances. Communication ensures one thread completes its task before another starts.

3. Real-World Analogy (Passing Tasks Between Workers): Think of a relay race where runners pass a baton:

• The first runner (producer) completes their lap and hands over the baton.
• The next runner (consumer) waits until they receive the baton before starting.
  This seamless handover ensures the race progresses without confusion or delays. Threads communicate similarly to pass tasks efficiently.

Therefore, in such situations, thread communication becomes important for:

• Ensuring that the tasks are completed in the right order.
• Preventing simultaneous resource access issues.
• Keeping threads from wasting time waiting or duplicating work.

In programming, mechanisms like locks, semaphores, and condition variables help achieve this synchronization, ensuring threads collaborate effectively.

Understanding Inter Thread Communication In Java

Inter-thread communication in Java programming is a mechanism that allows threads to communicate and coordinate their actions efficiently. It is essential when threads depend on shared resources or each other’s progress. Java provides built-in methods and tools to achieve smooth communication and synchronization.

Why Is Inter-Thread Communication Important?

When multiple threads interact:

• Coordination: Threads need to wait for each other or notify others when certain conditions are met.
• Resource Sharing: Threads must access shared resources without conflicts or race conditions.
• Avoiding Busy Waiting: A thread can wait to be notified rather than continuously checking for a condition, which optimizes performance.

How Does Java Enable Inter-Thread Communication?

Java provides the following methods in the Object class to support inter-thread communication:

These methods are used within synchronized blocks or methods to ensure thread safety.

The wait() Method In Inter-Thread Communication

The wait() method in Java is used for inter-thread communication. It makes the current thread pause its execution and release the lock it holds on the object, waiting until another thread signals it to resume using the notify() or notifyAll() methods.

This is particularly useful in scenarios where one thread needs to wait for a certain condition to be fulfilled by another thread before proceeding.

Key points about wait() method:

1. Releases the Lock: When a thread calls wait(), it releases the monitor (lock) of the object it is waiting on.
2. Must Be Called Inside a Synchronized Block/Method: This ensures thread safety while interacting with shared resources.
3. Thread Goes Into Waiting State: The thread will remain in the waiting state until notified.

Syntax: 

public final void wait() throws InterruptedException

Here: 

• wait(): Causes the current thread to wait indefinitely until it is notified.
• InterruptedException: The thread may throw this exception if interrupted while waiting.

Code Example: 

class SharedResource {

    private int data = 0;  
    private boolean hasData = false;  

    public synchronized void produce(int value) throws InterruptedException {
        while (hasData) {
            wait(); // Wait until the consumer consumes the data
        }
        data = value;
        hasData = true;
        System.out.println("Produced: " + data);
        notify(); // Notify the consumer that data is available
    }

    public synchronized void consume() throws InterruptedException {
        while (!hasData) {
            wait(); // Wait until the producer produces data
        }
        System.out.println("Consumed: " + data);
        hasData = false;
        notify(); // Notify the producer that space is available
    }
}

public class WaitExample {
    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();

        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    sharedResource.produce(i);
                    Thread.sleep(100); // Simulate production time
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    sharedResource.consume();
                    Thread.sleep(150); // Simulate consumption time
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

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

Output (set code file name as WaitExample.java): 

Produced: 1
Consumed: 1
Produced: 2
Consumed: 2
Produced: 3
Consumed: 3
Produced: 4
Consumed: 4
Produced: 5
Consumed: 5

Explanation: 

In the above code example-

1. We create a class SharedResource to represent a shared resource between a producer and a consumer. It includes a private integer data and a boolean variable hasData to track if data is available.
2. The produce() method is synchronized to ensure only one thread accesses it at a time. If hasData is true, the producer thread waits until the consumer processes the existing data.
3. Once the producer can proceed, it updates the data value, sets hasData to true, prints a message indicating the produced data, and notifies the consumer that data is ready.
4. The consume() method is also synchronized. If hasData is false, the consumer thread waits using wait() method until the producer generates new data.
5. When the consumer can proceed, it reads and prints the data, sets hasData to false to signal that the resource is empty, and notifies the producer to produce more data.
6. In the main() method, we instantiate the SharedResource and define two threads: one for the producer and one for the consumer.
7. The producer thread calls the produce() method in a loop, generating values from 1 to 5. After producing each value, it sleeps for 100 milliseconds to simulate a production delay.
8. The consumer thread calls the consume() method in a loop, consuming the produced values. It sleeps for 150 milliseconds after each consumption to simulate a consumption delay.
9. Both threads are started simultaneously. The producer generates data, and the consumer processes it in a coordinated manner using the wait() and notify() methods to manage thread communication.
10. This implementation ensures that the producer doesn’t overwrite unconsumed data and the consumer doesn’t read data before it’s produced, avoiding race conditions.

Explore this amazing course and master all the key concepts of Java programming effortlessly!

The notify() Method In Inter-Thread Communication

The notify() method in Java is used to wake up a single thread that is waiting on the monitor (lock) of the object. This method is part of the inter-thread communication mechanism and works in conjunction with the wait() method to ensure threads coordinate effectively.

Key points about notify() method:

1. Signals a Waiting Thread: It wakes up one thread that is waiting on the same object's monitor.
2. Used Inside Synchronized Blocks/Methods: The notify() must also be called within a synchronized block or method to maintain thread safety.
3. Does Not Immediately Release the Lock: The lock is released only when the notifying thread exits the synchronized block.

Syntax: 

public final void notify()

Here, the notify() method will wake up one thread waiting on the object’s monitor. If multiple threads are waiting, only one (chosen arbitrarily) will be notified.

Code Example: 

class SharedResource {

    private int data = 0;
    private boolean hasData = false;

    public synchronized void produce(int value) throws InterruptedException {
        while (hasData) {
            wait(); // Wait until the consumer consumes the data
        }
        data = value;
        hasData = true;
        System.out.println("Produced: " + data);
        notify(); // Notify the consumer that data is available
    }

    public synchronized void consume() throws InterruptedException {
        while (!hasData) {
            wait(); // Wait until the producer produces data
        }
        System.out.println("Consumed: " + data);
        hasData = false;
        notify(); // Notify the producer that space is available
    }
}

public class NotifyExample {
    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();

        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    sharedResource.produce(i);
                    Thread.sleep(100); // Simulate production time
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    sharedResource.consume();
                    Thread.sleep(150); // Simulate consumption time
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

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

Output (set code file name as NotifyExample.java): 

Produced: 1
Consumed: 1
Produced: 2
Consumed: 2
Produced: 3
Consumed: 3
Produced: 4
Consumed: 4
Produced: 5
Consumed: 5

Explanation: 

In the above code example-

1. We define a class SharedResource to coordinate data sharing between a producer and a consumer. It has a private integer data to store the shared value and a boolean hasData to track whether data is available for consumption.
2. The produce() method is synchronized to prevent concurrent access. If hasData is true, the producer thread waits until the consumer processes the existing data.
3. When allowed to proceed, the producer assigns the value to data, sets hasData to true, prints the produced value, and notifies the consumer that new data is ready using the notify() method.
4. The consume method is also synchronized to ensure thread-safe access. If hasData is false, the consumer waits until the producer generates new data.
5. Once the consumer can proceed, it reads and prints the data, sets hasData to false to indicate the resource is empty, and notifies the producer that it can produce more data.
6. In the main() method, we create an instance of SharedResource and define two threads: one for the producer and one for the consumer.
7. The producer thread loops through the produce() method, generating values from 1 to 5. After producing each value, it pauses for 100 milliseconds to simulate a production delay.
8. The consumer thread loops through the consume() method, consuming the generated values. After each consumption, it pauses for 150 milliseconds to simulate a consumption delay.
9. Both threads start concurrently. The producer generates data, and the consumer processes it in a synchronized manner using the wait and notify methods to manage coordination.

The notifyAll() Method In Inter-Thread Communication

The notifyAll() method in Java is used to wake up all threads that are waiting on the monitor (lock) of a given object. Unlike notify(), which wakes up only one thread, notifyAll() ensures that every thread waiting on the object's monitor gets a chance to proceed.

This is particularly useful when multiple threads may be waiting for a condition, and you want all of them to re-evaluate the condition when it changes.

Key points about notifyAll() method:

• Wakes All Waiting Threads: All threads waiting on the monitor of the object are notified, but only one thread can acquire the lock at a time.
• Used in Synchronized Blocks/Methods: Like notify(), notifyAll() must also be called inside a synchronized block or method.
• Thread Priority: The thread scheduler determines the order in which notified threads execute.

Syntax: 

public final void notifyAll()

Here, the notifyAll() method will wake up all threads that are waiting on the object’s monitor.

Code Example:

class SharedResource {

    private int data = 0;
    private boolean hasData = false;

    public synchronized void produce(int value) throws InterruptedException {
        while (hasData) {
            wait(); // Wait until the consumer consumes the data
        }
        data = value;
        hasData = true;
        System.out.println("Produced: " + data);
        notifyAll(); // Notify all waiting threads
    }

    public synchronized void consume() throws InterruptedException {
        while (!hasData) {
            wait(); // Wait until the producer produces data
        }
        System.out.println("Consumed: " + data);
        hasData = false;
        notifyAll(); // Notify all waiting threads
    }
}

public class NotifyAllExample {
    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();

        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    sharedResource.produce(i);
                    Thread.sleep(100); // Simulate production time
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer1 = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    sharedResource.consume();
                    Thread.sleep(150); // Simulate consumption time
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer2 = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    sharedResource.consume();
                    Thread.sleep(150); // Simulate consumption time
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer1.start();
        consumer2.start();
    }
}

Output (set code file name as NotifyAllExample.java): 

Produced: 1
Consumed: 1
Produced: 2
Consumed: 2
Produced: 3
Consumed: 3
Produced: 4
Consumed: 4
Produced: 5
Consumed: 5

Explanation: 

In the above code example-

1. We define a SharedResource class to coordinate data exchange between a producer and multiple consumers. It uses a private integer data to store the shared value and a boolean hasData to indicate if data is available for consumption.
2. The produce() method is synchronized to ensure thread-safe access. If hasData is true, the producer waits for consumers to process the data before producing new data.
3. When the producer can proceed, it assigns a value to data, sets hasData to true, prints the produced value, and calls notifyAll() method to wake up all waiting threads (consumers) so they can attempt to consume the new data.
4. The consume() method is also synchronized to maintain thread safety. If hasData is false, consumers wait until the producer generates new data.
5. When a consumer proceeds, it reads and prints the data, sets hasData to false to signal the resource is empty, and calls notifyAll() to wake up all waiting threads (including the producer) so they can continue their operations.
6. In the main() method, we create an instance of SharedResource and define one producer thread and two consumer threads to simulate concurrent operations.
7. The producer thread loops through the produce() method, generating values from 1 to 5. It pauses for 100 milliseconds between productions to simulate a production delay.
8. Each consumer thread loops through the consume() method, consuming the produced values. They pause for 150 milliseconds after each consumption to simulate a consumption delay.
9. All threads are started concurrently. The producer generates data, and the two consumers compete to process it in a synchronized manner, using wait() and notifyAll() for communication and coordination.
10. This implementation allows multiple consumers to operate on the shared resource while ensuring no data is consumed before being produced and no new data is produced until the current one is consumed. The use of notifyAll ensures all waiting threads are awakened when needed.

Sharpen your coding skills with Unstop's 100-Day Coding Sprint and compete now for a top spot on the leaderboard!

Difference Between wait() And sleep() Methods In Java

In Java, both the wait() and sleep() methods are used to pause the execution of a thread, but they serve different purposes and have distinct behaviors. While wait() is used in the context of inter-thread communication to release the lock and pause the thread's execution until notified, sleep() is used to pause the thread without releasing the lock. Let's explore their differences in detail through the following table:

Best Practices For Inter Thread Communication In Java

Here are some key best practices for inter-thread communication in Java:

• Use synchronized blocks or methods: Always use synchronization when calling wait(), notify(), or notifyAll() to avoid race conditions.
• Check conditions in a loop: Always use a loop (not an if statement) when calling wait() to handle spurious wakeups and ensure the condition is truly met.
• Minimize lock time: Hold locks for the shortest time possible to avoid blocking other threads and improving performance.
• Use notifyAll() for multiple threads: When multiple threads are waiting, use notifyAll() to wake up all waiting threads, not just one.
• Avoid deadlocks: Prevent deadlocks by acquiring locks in a consistent order and using timeouts when acquiring locks.
• Handle InterruptedException properly: Always handle InterruptedException by either re-interrupting the thread or managing the interruption gracefully.
• Use ExecutorService for thread management: Use ExecutorService to manage threads, as it simplifies thread pooling and task management.
• Avoid using Thread.sleep() for synchronization: Use wait() or notify() instead of sleep() for proper synchronization, as sleep() doesn’t release the lock.
• Minimize shared mutable state: Reduce shared mutable state between threads or use thread-safe collections to avoid synchronization issues.
• Use modern concurrency utilities: Use classes from java.util.concurrent like CountDownLatch, Semaphore, or BlockingQueue for easier and more efficient thread synchronization.
• Avoid busy-waiting: Don’t use constant polling loops to check conditions; instead, use wait() to allow threads to pause and release CPU resources.
• Use ReentrantLock for more control: Consider ReentrantLock for more advanced locking features and better control over synchronization.
• Document thread-specific behavior: Clearly document any multi-threading logic to make it easier for others to understand and maintain.

These practices will help you manage threads effectively, avoid common concurrency issues, and write more efficient, maintainable code.

Are you looking for someone to answer all your programming-related queries? Let's find the perfect mentor here.

Conclusion 

Inter-thread communication in Java plays a critical role in ensuring that threads can work together efficiently and safely, particularly in scenarios where shared resources need to be accessed or modified by multiple threads. By utilizing methods like wait(), notify(), and notifyAll(), threads can coordinate their actions and avoid common issues such as race conditions and deadlocks. Proper synchronization, careful handling of thread states, and the use of modern concurrency utilities are essential for writing effective, maintainable multi-threaded programs. Understanding and implementing these communication mechanisms allows developers to leverage Java's powerful concurrency features, leading to better performance, responsiveness, and scalability in concurrent applications.

Frequently Asked Questions

Q. What is inter-thread communication in Java?

Inter-thread communication in Java refers to the process through which multiple threads can communicate with each other to share information or coordinate their actions while accessing shared resources. It allows threads to signal each other when specific conditions are met or when certain resources become available. This is achieved using methods such as wait(), notify(), and notifyAll(), which are typically called within synchronized blocks or methods to ensure thread safety.

Q. How do wait(), notify(), and notifyAll() work in inter-thread communication?

They work as follows:

• wait(): This method is used by a thread to release the lock it holds on an object and enter the waiting state. The thread will remain in this state until another thread notifies it.
• notify(): This method wakes up one of the threads that are waiting on the object's monitor (lock). If multiple threads are waiting, only one is awakened, and the choice is arbitrary.
• notifyAll(): This method wakes up all threads that are currently waiting on the object's monitor. It is typically used when more than one thread could be waiting for the same condition to be met.

All these methods must be called within a synchronized block or method because they involve shared resources and require mutual exclusion.

Q. What are spurious wakeups, and how can they affect inter-thread communication?

A spurious wakeup occurs when a thread that is waiting on an object is awakened without any thread calling notify() or notifyAll(). This can happen in some JVM implementations. To handle spurious wakeups, it’s a good practice to use a while loop to check the condition before proceeding, rather than an if statement. This ensures that the thread only continues execution when the condition it’s waiting for is truly satisfied, even if it was woken up spuriously.

Q. What is the difference between notify() and notifyAll()?

• notify(): Wakes up a single thread that is waiting on the object’s monitor. If multiple threads are waiting, it wakes up only one of them, and which thread gets awakened is not guaranteed.
• notifyAll(): Wakes up all threads waiting on the object’s monitor. This is useful when you need all waiting threads to have an opportunity to proceed, as each thread will check its condition upon being awakened.

Thus, notifyAll() is often preferred when multiple threads are waiting for different conditions to be met, as it avoids missing a notification.

Q. Why do we need to use synchronization when using wait(), notify(), or notifyAll()?

The wait(), notify(), and notifyAll() methods must be called from within a synchronized block or method because they operate on shared resources. Without synchronization, there is no guarantee that the threads will have exclusive access to the object’s monitor when they attempt to call these methods. This can lead to race conditions, where multiple threads try to change shared data simultaneously, causing inconsistent or incorrect results.

Q. What happens if a thread is interrupted while waiting?

If a thread is interrupted while waiting (i.e., it calls wait()), it throws an InterruptedException. Proper handling of this exception is necessary to maintain thread safety and avoid unexpected termination. Typically, the thread should either catch the exception and handle it appropriately or re-interrupt itself by calling Thread.currentThread().interrupt() to preserve the interrupt status for other components of the application to react to the interruption.

Q. What are some common use cases for inter-thread communication in Java?

Inter-thread communication is commonly used in scenarios where threads need to cooperate or share data. Some typical use cases include:

• Producer-consumer problem: One thread (the producer) generates data, and another thread (the consumer) processes the data. The consumer waits for data to be produced, and the producer waits for space to store new data.
• Task scheduling: Threads that depend on the completion of certain tasks before proceeding can use inter-thread communication to coordinate task execution.
• Resource pooling: In computer systems where a limited number of resources are shared, threads may need to wait until a resource becomes available before proceeding.

With this, we conclude our discussion on inter-thread communication in Java. Here are a few other topics that you might want to read: 

1. Final, Finally & Finalize In Java | 15+ Differences With Examples
2. Super Keyword In Java | Definition, Applications & More (+Examples)
3. How To Find LCM Of Two Numbers In Java? Simplified With Examples
4. How To Find GCD Of Two Numbers In Java? All Methods With Examples
5. Throws Keyword In Java | Syntax, Working, Uses & More (+Examples)
6. 10 Best Books On Java In 2024 For Successful Coders
7. Difference Between Java And JavaScript Explained In Detail
8. Top 15+ Difference Between C++ And Java Explained! (+Similarities)