1. Using BlockingQueue is the most direct and recommended way to implement the Java producer-consumer model. It handles thread synchronization internally. The producer calls the put() method to block waiting queue space, and the consumer calls the take() method to block waiting data; 2. If the manual implementation requires the synchronized locking and wait/notify mechanism to coordinate thread behavior, the core is to loop check the conditions and operate the shared buffer within the synchronization block; 3. Notes include correct handling of interrupts, multi-threaded wake-up strategy to select notifyAll(), setting a reasonable buffer size, and elegantly closing threads.

In Java multithreaded programming, implementing the producer-consumer model is a common concurrency model. It is mainly used to solve the problem of collaboration between multiple threads: one or more threads are responsible for "production" of data, and another or more threads are responsible for "consuming" this data.

To implement this model, the key is how to safely pass data between threads and avoid resource competition and deadlock problems. Let’s start from several practical perspectives and talk about how to do it in detail.

Using BlockingQueue is the most direct way

Java provides ready-made BlockingQueue interfaces (such as ArrayBlockingQueue or LinkedBlockingQueue ), which has handled thread synchronization problems internally and is the most recommended method for implementing producer-consumer.

It is very simple to use:

• The producer calls put() method to put data into the queue
• The consumer calls take() method to retrieve data from the queue

Both methods are blocking, and when the queue is full, the producer will wait; when the queue is empty, the consumer will wait, which is exactly the same as our desired behavior.

Sample code snippet:

 BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

// Producer thread new Thread(() -> {
    try {
        int i = 0;
        while (true) {
            queue.put(i);
            System.out.println("Produced: " i);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

// Consumer thread new Thread(() -> {
    try {
        while (true) {
            int value = queue.take();
            System.out.println("Consumed: " value);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

If you do not use the ready-made queue, you can manually add lock control

If you don't want to rely on BlockingQueue , you can also implement the logic manually. At this time, synchronized keywords and wait/notify mechanisms need to be used to coordinate thread behavior.

Core idea:

• Use a shared data structure (such as List ) as a buffer
• Locking when operating the buffer
• When the buffer is full, the producer thread waits; wakes up when there is space
• When the buffer is empty, the consumer thread waits; wakes up when new data is available

Notes:

• Conditions must be checked in the loop because there may be false wakeups
• Calling wait() and notify() must be done in the synchronization block

Example pseudocode:

 public class SharedBuffer {
    private List<Integer> buffer = new ArrayList<>();
    private final int MAX_SIZE = 10;

    public synchronized void put(int value) throws InterruptedException {
        while (buffer.size() == MAX_SIZE) {
            wait();
        }
        buffer.add(value);
        notifyAll();
    }

    public synchronized int take() throws InterruptedException {
        while (buffer.isEmpty()) {
            wait();
        }
        int value = buffer.remove(0);
        notifyAll();
        return value;
    }
}

A few easy to ignore but important details

• Interrupt handling : The thread may be interrupted. Remember to capture InterruptedException and restore the interrupt state.
• Wake-up strategy in multi-producer/consumer scenarios : If there are many threads waiting, try to use notifyAll() instead of notify() to avoid missing wake-up
• Setting a reasonable buffer size : Too large will waste memory, too small may lead to frequent waiting
• Elegantly close threads : loop exit can be controlled by adding flag bits instead of infinite loops not handling exit conditions

Basically that's it. BlockingQueue can quickly implement functions, while manual implementation can help you understand the underlying mechanism. The two methods have their own applicable scenarios. By choosing the right tool, you can write a stable and efficient concurrent program.

The above is the detailed content of Implementing Producer-Consumer pattern using Java threads.. For more information, please follow other related articles on the PHP Chinese website!