Inter-Thread Communication Part 2: Communication Patterns

 Introduction

In concurrent programming, effective inter-thread communication is crucial for coordinating the execution and data exchange between multiple threads. Java provides various communication patterns and mechanisms that enable threads to synchronize their actions, share data, and ensure proper coordination. In this second part of our series on inter-thread communication, we will explore different communication patterns in Java. By understanding these patterns, you will be able to design robust and collaborative multithreaded applications. Let's dive into the world of communication patterns for inter-thread coordination.

Wait and Notify

The wait() and notify() methods, available in the Object class, provide a classic inter-thread communication pattern in Java. Threads use these methods to wait for specific conditions to be met before proceeding with their execution or notifying other threads about a change in state.

Example

class SharedResource {
    private boolean flag = false;
    synchronized void waitForCondition() throws InterruptedException {
        while (!flag) {
            wait(); // Thread waits until the condition is met
        }
        // Perform task when the condition is true
        // ...
    }
    synchronized void setFlag(boolean value) {
        flag = value;
        notifyAll(); // Signal waiting threads that the condition has changed
    }
}

In the above example, the waitForCondition() method waits until the flag condition is true, using the wait() method. The setFlag() method changes the flag and notifies waiting threads using notifyAll(). This pattern enables threads to wait for a condition to be fulfilled before proceeding.

Blocking Queues

Blocking queues, available in the java.util.concurrent package, provide a powerful inter-thread communication pattern for producer-consumer scenarios. Blocking queues allow threads to exchange data efficiently, with built-in mechanisms for synchronization and coordination.

Example:

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
class Producer implements Runnable {
    private BlockingQueue<Integer> queue;
    Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }
    public void run() {
        try {
            // Produce items and put them into the queue
            for (int i = 0; i < 10; i++) {
                queue.put(i);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}
class Consumer implements Runnable {
    private BlockingQueue<Integer> queue;
    Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }
    public void run() {
        try {
            // Consume items from the queue
            while (true) {
                int item = queue.take();
                // Process the item
                // ...
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}
public class Main {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        Thread producerThread = new Thread(new Producer(queue));
        Thread consumerThread = new Thread(new Consumer(queue));
        producerThread.start();
        consumerThread.start();
    }
}

In the above example, the producer thread puts items into the blocking queue using the put() method, while the consumer thread takes items from the queue using the take() method. The blocking queue handles the synchronization and coordination between the producer and consumer threads, ensuring that the producer waits when the queue is full and the consumer waits when the queue is empty.

Signaling with Conditions

Conditions, available in the java.util.concurrent.locks package, provide a flexible inter-thread communication pattern. Conditions allow threads to wait for specific conditions to be met and provide mechanisms for signaling other threads when the condition changes.

Example:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class SharedResource {
    private boolean flag = false;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    void waitForCondition() throws InterruptedException {
        lock.lock();
        try {
            while (!flag) {
                condition.await(); // Thread waits until the condition is met
            }
            // Perform task when the condition is true
            // ...
        } finally {
            lock.unlock();
        }
    }
    void setFlag(boolean value) {
        lock.lock();
        try {
            flag = value;
            condition.signalAll(); // Signal waiting threads that the condition has changed
        } finally {
            lock.unlock();
        }
    }
}

In the above example, the waitForCondition() method waits until the flag condition is true, using the await() method. The setFlag() method changes the flag and signals waiting threads using signalAll(). Conditions provide more fine-grained control over thread coordination compared to wait() and notify().

Conclusion

Communication patterns are essential for inter-thread coordination and data exchange in concurrent programming. In this second part of our series, we explored the wait and notify pattern, blocking queues, and signaling with conditions. These patterns enable threads to synchronize their actions, wait for specific conditions, and exchange data safely and efficiently. By leveraging these communication patterns, you can design robust and collaborative multithreaded applications that make the most of the available resources. Stay tuned for the next part of our series, where we will dive deeper into advanced topics related to inter-thread communication in Java.