5. Implement a Multi-threaded Producer-Consumer Problem in Java: FAANG Interviews

The Producer-Consumer problem is a classic concurrency challenge often asked in interviews. It involves two types of threads: producers and consumers. The producers create data, and the consumers consume it. Both types of threads share a common buffer (usually a queue) that stores the data, but they must access the buffer safely to prevent issues such as race conditions, deadlocks, and inconsistent data.

This problem can be efficiently solved by utilizing Java's concurrency tools such as thread synchronization, condition variables, and the wait-notify mechanism. Let's dive into the core concepts and the solution to the Producer-Consumer problem.

Key Concepts:

1. Thread Synchronization: Thread synchronization ensures that only one thread accesses shared data at a time, preventing race conditions.
2. Condition Variables and wait-notify: The wait and notify methods allow threads to wait for certain conditions to be met before proceeding, which helps coordinate producers and consumers.
3. Deadlock Prevention: Deadlocks occur when threads are waiting on each other indefinitely. Proper synchronization and control flow can help prevent this.
4. Thread Safety and Atomic Operations: Atomic operations ensure that a particular operation on a shared resource happens atomically, preventing interruptions from other threads.

Solution Overview:

In the producer-consumer problem, we’ll use a shared buffer (a queue) that is accessed by both producers and consumers. The producers will add data to the buffer, and the consumers will remove data. We need to ensure that when a producer adds data, the buffer is not full, and when a consumer removes data, the buffer is not empty. Additionally, we must ensure that threads do not interfere with each other in unsafe ways.

We’ll implement this solution using synchronized blocks for synchronization and a BlockingQueue for thread-safe queue operations.

Example Code:

import java.util.LinkedList;
import java.util.Queue;

// Shared Buffer
class Buffer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int capacity = 10; // Maximum buffer size

    // Producer adds an item to the buffer
    public synchronized void produce(int item) throws InterruptedException {
        while (queue.size() == capacity) {
            wait();  // Wait until space becomes available
        }
        queue.add(item);
        System.out.println("Produced: " + item);
        notify();  // Notify consumers that there's something to consume
    }

    // Consumer removes an item from the buffer
    public synchronized int consume() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();  // Wait until the buffer is not empty
        }
        int item = queue.poll();
        System.out.println("Consumed: " + item);
        notify();  // Notify producers that there's space available
        return item;
    }
}

// Producer thread
class Producer extends Thread {
    private final Buffer buffer;

    public Producer(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 20; i++) {
                buffer.produce(i);
                Thread.sleep(100);  // Simulate time taken to produce an item
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// Consumer thread
class Consumer extends Thread {
    private final Buffer buffer;

    public Consumer(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 20; i++) {
                buffer.consume();
                Thread.sleep(150);  // Simulate time taken to consume an item
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        Buffer buffer = new Buffer();
        
        // Create and start the producer and consumer threads
        Thread producerThread = new Producer(buffer);
        Thread consumerThread = new Consumer(buffer);
        
        producerThread.start();
        consumerThread.start();
    }
}

Explanation of the Code:

1. Buffer Class:

   • The Buffer class acts as a shared resource for both producers and consumers. It uses a Queue<Integer> to hold the items being produced and consumed.
   • The produce() method adds an item to the queue if there is space available (it waits if the buffer is full).
   • The consume() method removes an item from the queue if the buffer is not empty (it waits if the buffer is empty).

2. Producer Class:

   • The Producer class is a thread that produces items and adds them to the buffer. It will produce 20 items and simulate a delay of 100 milliseconds between productions.

3. Consumer Class:

   • The Consumer class is a thread that consumes items from the buffer. It will consume 20 items and simulate a delay of 150 milliseconds between consumptions.

4. Thread Synchronization:

   • Both the produce() and consume() methods are synchronized to ensure that only one thread accesses the shared buffer at a time.
   • The wait() and notify() methods are used to make threads wait for a condition (e.g., waiting for space or items in the buffer) and to notify the other threads when the condition has changed.

5. Deadlock Prevention:

   • The synchronized blocks in both produce() and consume() ensure that access to the shared resource is controlled. By using wait() and notify(), we avoid situations where threads wait indefinitely for each other, thereby preventing deadlocks.

6. Atomic Operations:

   • The operations on the buffer (adding and removing items) are atomic in the sense that once a thread enters a synchronized block, no other thread can interfere until the operation completes.

Conclusion:

This example demonstrates a simple and effective way to solve the Producer-Consumer problem in Java using thread synchronization, the wait-notify mechanism, and atomic operations. By utilizing synchronization and careful control over the flow of execution, we ensure that both the producer and consumer can operate safely without causing race conditions, deadlocks, or inconsistencies in the shared resource. 

This solution can be extended or modified to fit more complex scenarios, such as having multiple producers and consumers or using other concurrency tools like Locks and Condition variables.

Please stay tune, I will update Point 6 of FANNG Interview series, Please check top 10 interview questions here.