Java Programming Inter Thread Communication Complete Guide

Let's go through a step-by-step example to illustrate how these concepts can be used. We'll create a simple producer-consumer problem, which is a classic example of inter-thread communication.

Problem Statement

We have a SharedResource class that holds an integer. There are two threads, a Producer and a Consumer. The Producer thread generates values and stores them in the SharedResource. The Consumer thread retrieves these values from the SharedResource. However, it should be ensured that the Consumer does not consume a value until the Producer has produced it, and similarly, the Producer should not produce a new value until the Consumer has consumed the existing one.

Step-by-Step Implementation

Step 1: Define the SharedResource Class

This class will contain the integer value and provide synchronized methods for setting and getting the value.

public class SharedResource {
    private int data;
    private boolean valueSet = false;

    public synchronized void set(int value) {
        while (valueSet) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Producer interrupted");
            }
        }
        this.data = value;
        valueSet = true;
        System.out.println("Produced: " + data);
        notify();
    }

    public synchronized int get() {
        while (!valueSet) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Consumer interrupted");
            }
        }
        valueSet = false;
        System.out.println("Consumed: " + data);
        notify();
        return data;
    }
}

Step 2: Define the Producer Class

The Producer class will extend Thread and will continuously produce and set the data in the SharedResource.

public class Producer extends Thread {
    private SharedResource sharedResource;

    public Producer(SharedResource sharedResource) {
        this.sharedResource = sharedResource;
    }

    @Override
    public void run() {
        int counter = 0;
        while (true) {
            sharedResource.set(counter++);
            try {
                Thread.sleep(1000); // Simulate time delay
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Producer Thread interrupted");
            }
        }
    }
}

Step 3: Define the Consumer Class

The Consumer class will extend Thread and will continuously get and consume the data from the SharedResource.

public class Consumer extends Thread {
    private SharedResource sharedResource;

    public Consumer(SharedResource sharedResource) {
        this.sharedResource = sharedResource;
    }

    @Override
    public void run() {
        while (true) {
            sharedResource.get();
            try {
                Thread.sleep(2000); // Simulate time delay
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Consumer Thread interrupted");
            }
        }
    }
}

Step 4: Define the Main Class

This class will create an instance of SharedResource, a Producer, and a Consumer, and start both threads.

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

        Producer producer = new Producer(sharedResource);
        Consumer consumer = new Consumer(sharedResource);

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

Explanation

1. SharedResource: Contains the methods set() and get(), which are synchronized. The set() method waits if valueSet is true (i.e., the previous value has not been consumed yet), and after setting the new value, it calls notify() to wake up the waiting get() method. Similarly, the get() method waits if valueSet is false and notifies the set() method once the value is consumed.
2. Producer: An infinite loop which continuously increments a counter, sets the counter in the SharedResource, and sleeps for 1 second.
3. Consumer: An infinite loop which continuously retrieves the counter from the SharedResource and sleeps for 2 seconds.
4. Main: Creates a SharedResource object and two threads (Producer and Consumer). It starts both threads.

Output

The output will show the producer producing values and the consumer consuming them. Since the consumer's sleep time is longer than the producer's, you will see two produced values for each consumed value. However, the consumer will only consume a value when it is available (i.e., when the producer has produced it).