Introduction

Inter Thread Communication is a technique through which multiple threads communicate with each other.

In Java, threads can communicate with each other through several mechanisms, including:

• Shared memory: Threads can communicate by sharing memory regions. Each thread can read and write data to the shared memory area, allowing them to exchange information.

• Synchronization: Threads can use synchronization constructs such as locks, semaphores, and monitors to coordinate access to shared resources. This prevents multiple threads from accessing the same resource simultaneously and ensures that only one thread can modify the resource at a time.

• Wait and notify: Threads can use the wait() and notify() methods to signal each other. When a thread calls wait(), it will release any locks it holds and wait for another thread to call notify() or notifyAll() on the same object. This allows threads to synchronize their execution and coordinate their actions.

• Pipes and streams: Threads can communicate through pipes and streams, which provide a one-way communication channel between threads. One thread writes data to the stream, while another thread reads the data from the stream.

These are some of the mechanisms that Java provides for inter-thread communication. It's important to use them carefully to avoid race conditions, deadlocks, and other concurrency issues.

Using Wait and notify

wait() method

wait() is a method defined in the Object class in Java, and it is used in the context of multithreading and synchronization to make a thread wait until a certain condition is met. When a thread calls wait(), it temporarily releases the lock on the object's monitor that it holds, allowing other threads to enter the synchronized block or method and access the shared resource. The thread then waits until it is notified by another thread that the condition it was waiting for has been met.

The wait() method has the following signature:

1public final void wait() throws InterruptedException

The wait() method can throw an InterruptedException if the waiting thread is interrupted by another thread while it is waiting. This exception can be caught and handled by the waiting thread.

Here's an example of how wait() can be used in Java:

Example Usage

1synchronized (sharedObject) {
2  while (!condition) {
3    try {
4      sharedObject.wait(); // thread waits until condition is true
5    } catch (InterruptedException e) {
6      e.printStackTrace();
7    }
8  }
9  // code to be executed after condition is true
10}

• In this example, a thread acquires the lock on sharedObject, and then enters a while loop to wait for a specific condition to become true.
• If the condition is not true, the thread calls wait() on sharedObject, which releases the lock and waits until it is notified by another thread.
• Once the condition becomes true, the thread is notified by another thread calling notify() or notifyAll() on sharedObject, and it proceeds with executing the code after the while loop.

notify() method

notify() is a method defined in the Object class in Java, and it is used to wake up a single thread that is waiting on the object's monitor. When notify() is called, it wakes up one of the threads that are waiting on the same object's monitor. However, which thread is awakened is not deterministic and depends on the JVM's implementation.

The notify() method has the following signature:

1public final void notify()

Example Usage

1synchronized (sharedObject) {
2  while (!condition) {
3    try {
4      sharedObject.wait(); // thread waits until condition is true
5    } catch (InterruptedException e) {
6      e.printStackTrace();
7    }
8  }
9  // code to be executed after condition is true
10  sharedObject.notify(); // Wake up one waiting thread
11}
12

• In this example, a thread acquires the lock on the sharedObject monitor using the synchronized keyword, and then calls notify() to signal to one of the threads waiting on the same monitor that it can proceed.
• The awakened thread will then compete with other threads for the lock to continue its execution.

notifyAll() method

notifyAll() is a method defined in the Object class in Java, and it is used to wake up all threads which are waiting on the object's monitor. It is used in conjunction with wait() to coordinate the execution of multiple threads and enable inter-thread communication.

The notifyAll() method has the following signature:

1public final void notifyAll()

Example Usage

1synchronized (sharedObject) {
2  while (!condition) {
3    try {
4      sharedObject.wait(); // thread waits until condition is true
5    } catch (InterruptedException e) {
6      e.printStackTrace();
7    }
8  }
9  // code to be executed after condition is true
10  sharedObject.notifyAll(); // Wakes up all waiting threads
11}

• In this example, a thread acquires the lock on the sharedObject monitor using the synchronized keyword, and then calls notifyAll() to signal all threads which are waiting on the same monitor.
• The awakened threads will then compete with other threads for the lock to continue its execution.

Note : notifyAll() method wakes up all the threads that are waiting on the shared object, but the choice of which thread to wake up is arbitrary and cannot be controlled. Therefore, it's important to design the application carefully to avoid race conditions, deadlocks, and other concurrency issues.