Inter-thread Communication in Java

by

In Java, threads can communicate with each other by using various techniques. Here are some of the most common ways:

  1. Shared Memory: Threads can share data by accessing the same memory location. To prevent race conditions and other issues, it is important to use synchronization mechanisms such as locks or semaphores.
  2. Message Passing: Threads can send messages to each other using various communication mechanisms such as pipes, sockets, or Java Message Service (JMS).
  3. Wait/Notify: Threads can use the wait() and notify() methods provided by the Object class to signal each other. The wait() method causes the calling thread to wait until another thread notifies it. The notify() method wakes up a single thread that is waiting on the same object.
  4. Barrier: Threads can use a barrier to synchronize with each other. A barrier is a synchronization mechanism that blocks threads until all of them have reached a certain point in their execution.
  5. Future/Promise: Threads can use the Future and Promise classes to communicate asynchronously. A Future represents the result of an asynchronous operation, while a Promise represents a value that will be available at some point in the future.

These are just some of the ways that threads can communicate with each other in Java. The choice of which technique to use depends on the specific requirements of the application.

1) wait() method:

The wait() method is a method provided by the Object class in Java that causes the current thread to wait until another thread notifies it. It can be called on any object, and the calling thread must own the object’s monitor (obtained by synchronizing on the object) before calling wait().

The wait() method has several overloaded versions that allow you to specify a timeout, which means that if the calling thread has not been notified within the specified time, it will resume execution automatically.

When a thread calls wait(), it releases the object’s monitor and enters a waiting state. It remains in this state until another thread calls notify() or notifyAll() on the same object. When a thread is notified, it does not immediately resume execution; it must first reacquire the object’s monitor by obtaining a lock on the object.

Here is an example of how the wait() method can be used for inter-thread communication:

// Create a shared object
Object sharedObj = new Object();

// Thread 1
synchronized (sharedObj) {
   try {
      // Wait for Thread 2 to notify
      sharedObj.wait();
   } catch (InterruptedException e) {
      // Handle the exception
   }
}

// Thread 2
synchronized (sharedObj) {
   // Do some processing
   // Notify Thread 1
   sharedObj.notify();
}

In this example, Thread 1 waits for Thread 2 to notify it before continuing its execution. Thread 2 performs some processing and then notifies Thread 1 by calling notify() on the shared object. Note that both threads synchronize on the same object before calling wait() and notify().

2) notify() method:

The notify() method is a method provided by the Object class in Java that wakes up a single thread that is waiting on the same object. When notify() is called, it does not immediately release the object’s monitor; the thread that called notify() must first release the lock on the object by exiting the synchronized block.

Here is an example of how the notify() method can be used for inter-thread communication:

// Create a shared object
Object sharedObj = new Object();

// Thread 1
synchronized (sharedObj) {
   try {
      // Wait for Thread 2 to notify
      sharedObj.wait();
   } catch (InterruptedException e) {
      // Handle the exception
   }
}

// Thread 2
synchronized (sharedObj) {
   // Do some processing
   // Notify Thread 1
   sharedObj.notify();
}

In this example, Thread 1 waits for Thread 2 to notify it before continuing its execution. Thread 2 performs some processing and then notifies Thread 1 by calling notify() on the shared object. Note that both threads synchronize on the same object before calling wait() and notify(). Also, note that notify() wakes up only one thread waiting on the object, so if there are multiple threads waiting, only one of them will be awakened.

It’s important to note that the notify() method only wakes up a single waiting thread, so if there are multiple threads waiting on the same object, it’s possible that the wrong thread may be awakened. To avoid this, you can use the notifyAll() method instead, which wakes up all threads waiting on the object. However, this can also lead to unnecessary wakeups, which may reduce performance.

3) notifyAll() method:

The notifyAll() method is a method provided by the Object class in Java that wakes up all threads that are waiting on the same object. When notifyAll() is called, it does not immediately release the object’s monitor; the thread that called notifyAll() must first release the lock on the object by exiting the synchronized block.

Here is an example of how the notifyAll() method can be used for inter-thread communication:

// Create a shared object
Object sharedObj = new Object();

// Thread 1
synchronized (sharedObj) {
   try {
      // Wait for Thread 2 to notify
      sharedObj.wait();
   } catch (InterruptedException e) {
      // Handle the exception
   }
}

// Thread 2
synchronized (sharedObj) {
   // Do some processing
   // Notify all waiting threads
   sharedObj.notifyAll();
}

In this example, Thread 1 waits for Thread 2 to notify it before continuing its execution. Thread 2 performs some processing and then notifies all waiting threads by calling notifyAll() on the shared object. Note that both threads synchronize on the same object before calling wait() and notifyAll(). Also, note that notifyAll() wakes up all threads waiting on the object, so if there are multiple threads waiting, all of them will be awakened.

It’s important to note that the notifyAll() method wakes up all waiting threads, which can lead to unnecessary wakeups and reduced performance. Therefore, it’s a good practice to use notify() when only one thread needs to be awakened, and notifyAll() when multiple threads need to be awakened.

Understanding the process of inter-thread communication:

Inter-thread communication refers to the process of coordinating the execution of multiple threads in a way that allows them to work together to achieve a common goal. This can be achieved through the use of shared objects and the wait-notify mechanism in Java.

In Java, inter-thread communication is typically achieved through the following steps:

  1. Two or more threads are created and share a common object.
  2. Each thread must acquire a lock on the shared object’s monitor by synchronizing on the object.
  3. The thread that needs to wait calls the wait() method on the shared object, releasing the lock and entering a waiting state until it is notified by another thread.
  4. The thread that needs to notify other threads calls the notify() or notifyAll() method on the shared object, waking up the waiting threads and allowing them to continue execution.
  5. The notified threads must reacquire the lock on the shared object’s monitor by synchronizing on the object before they can proceed with their work.

It’s important to note that while the wait-notify mechanism is a powerful tool for inter-thread communication, it must be used carefully to avoid deadlocks, livelocks, and other concurrency-related issues. Therefore, it’s important to have a good understanding of concurrency and synchronization concepts before attempting to use the wait-notify mechanism in Java.

Why wait(), notify() and notifyAll() methods are defined in Object class not Thread class?

The wait(), notify(), and notifyAll() methods are defined in the Object class rather than the Thread class because they are related to the synchronization mechanism provided by Java and not specific to threads themselves.

In Java, synchronization is achieved through the use of an object’s monitor, which is acquired through the synchronized keyword. When a thread enters a synchronized block, it acquires the monitor on the object that is being synchronized on. The wait(), notify(), and notifyAll() methods are then used to manage the state of the monitor and control the execution of threads that are waiting on it.

Since these methods are used to manage the monitor on an object and not the thread itself, they are defined in the Object class, which is the root of all Java objects. This allows any object in Java to use the wait-notify mechanism for inter-thread communication, regardless of its specific type or implementation.

Additionally, defining these methods in the Object class makes it possible to use them in a more flexible and extensible way. For example, you can define your own classes that use the wait-notify mechanism by simply synchronizing on an instance of that class and calling the appropriate methods, without needing to subclass the Thread class or implement any specific interfaces.

Difference between wait and sleep?

The wait() and sleep() methods in Java are used to pause the execution of a thread, but they have some key differences:

  1. Object ownership: The wait() method is called on an object, while the sleep() method is called on a thread. The wait() method is used for synchronization purposes, while the sleep() method is used for time-based operations.
  2. Lock release: When a thread calls wait() on an object, it releases the lock on the object, allowing other threads to acquire it and modify the object’s state. On the other hand, when a thread calls sleep(), it does not release any locks it holds on objects.
  3. Notification: When a thread calls wait() on an object, it waits for another thread to call notify() or notifyAll() on the same object to wake it up. In contrast, when a thread calls sleep(), it does not rely on any other thread to wake it up – it simply waits for the specified time period to elapse and then resumes execution.
  4. Exceptions: The wait() method throws an InterruptedException if the thread is interrupted while waiting, while the sleep() method throws an InterruptedException if the thread is interrupted while sleeping.

In summary, wait() is used for synchronization purposes, and is typically used in conjunction with the synchronized keyword to coordinate the execution of multiple threads. sleep() is used for time-based operations, and is typically used to introduce delays in a program or to implement timeouts.

Example of Inter Thread Communication in Java:

Sure, here’s an example of inter-thread communication in Java using the wait-notify mechanism:

public class SharedObject {
    private int value;
    private boolean isValueSet = false;
    
    public synchronized void setValue(int value) {
        // Wait until the value is consumed by another thread
        while (isValueSet) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Producer produced: " + value);
        this.value = value;
        isValueSet = true;
        // Notify the waiting thread that a value has been set
        notify();
    }
    
    public synchronized int getValue() {
        // Wait until a value is produced by another thread
        while (!isValueSet) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Consumer consumed: " + value);
        isValueSet = false;
        // Notify the waiting thread that the value has been consumed
        notify();
        return value;
    }
}

In this example, we have a SharedObject class that is shared between two threads – a producer and a consumer. The setValue() method is called by the producer to set the value of the shared object, while the getValue() method is called by the consumer to retrieve the value.

The setValue() method first waits until the consumer has consumed the previous value by calling wait() in a loop until isValueSet is false. Once it has the lock on the object, it sets the value and sets isValueSet to true before calling notify() to notify the consumer thread that a new value has been set.

The getValue() method first waits until the producer has produced a new value by calling wait() in a loop until isValueSet is true. Once it has the lock on the object, it retrieves the value and sets isValueSet to false before calling notify() to notify the producer thread that the value has been consumed.

Here’s an example of how the SharedObject class can be used to coordinate the producer and consumer threads:

public class Main {
    public static void main(String[] args) {
        SharedObject sharedObject = new SharedObject();
        
        Thread producerThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                sharedObject.setValue(i);
            }
        });
        
        Thread consumerThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                int value = sharedObject.getValue();
            }
        });
        
        producerThread.start();
        consumerThread.start();
    }
}

In this example, the main() method creates a new SharedObject instance and two threads – a producer thread and a consumer thread. The producer thread sets five values on the shared object using the setValue() method, while the consumer thread retrieves five values using the getValue() method. The use of wait() and notify() in the setValue() and getValue() methods ensures that the threads are synchronized and that the consumer thread only retrieves values that have been set by the producer thread.