Java生产者消费者模型

在多线程编程中，生产者消费者模型是一个经典的问题。它是指有两个线程，一个是生产者，一个是消费者，它们共享同一个数据缓冲区。生产者线程向数据缓冲区中添加数据，而消费者线程从缓冲区中取出数据。

Java提供了多种机制来实现生产者消费者模型，本文将介绍其中两种：使用wait()和notifyAll()方法以及使用BlockingQueue。

一、使用wait()和notifyAll()方法

这种方法需要自己实现缓冲区，并调用Object类的wait()和notifyAll()方法来实现线程之间的同步。具体实现如下：

class Buffer {
    private Queue<Integer> queue = new LinkedList<>();
    private int maxSize;

    public Buffer(int size) {
        this.maxSize = size;
    }

    public synchronized void addToBuffer(int number) {
        while (queue.size() == maxSize) {
            try {
                wait(); 
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); 
                return;
            }
        }
        queue.add(number);
        notifyAll(); 
    }

    public synchronized int getFromBuffer() {
        while (queue.isEmpty()) {
            try {
                wait(); 
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); 
                return -1;
            }
        }
        int number = queue.remove();
        notifyAll(); 
        return number;
    }
}

在这个例子中，Buffer类表示缓冲区，addToBuffer方法往缓冲区中添加数据，getFromBuffer方法从缓冲区中取出数据。如果缓冲区已满，线程会阻塞等待缓冲区被取走一部分；如果缓冲区为空，线程会阻塞等待缓冲区被填充。

使用wait()和notifyAll()方法可以实现生产者消费者模型，但是需要手动同步和管理线程的状态，容易出现错误。如果有更好的方法，还是应该优先考虑其他的方式。

二、使用BlockingQueue

Java的java.util.concurrent包提供了一个BlockingQueue接口，实现了线程安全的队列操作。由于BlockingQueue是线程安全的，所以可以很方便地实现生产者消费者模型。

示例代码如下：

class Producer implements Runnable {
    private BlockingQueue<Integer> queue;
    private int maxSize;

    public Producer(BlockingQueue<Integer> queue, int size) {
        this.queue = queue;
        this.maxSize = size;
    }

    @Override
    public void run() {
        for (int i = 0; i < maxSize; i++) {
            try {
                queue.put(i);
                System.out.println("Producing: " + i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable {
    private BlockingQueue<Integer> queue;

    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Integer number = queue.take();
                System.out.println("Consuming: " + number);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
        Producer producer = new Producer(queue, 10);
        Consumer consumer = new Consumer(queue);
        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

这段代码中使用了ArrayBlockingQueue来实现，ArrayBlockingQueue的大小为10。Producer类是生产者线程，不停地往队列中添加数据；Consumer类是消费者线程，不停地从队列中取出数据。在Main类中创建生产者和消费者线程，并启动它们。

三、总结

生产者消费者模型是一个经典的多线程问题，它可以应用于很多实际应用场景中。Java提供了多种方式来实现这个模型，其中比较常用的有使用wait()和notifyAll()方法和使用BlockingQueue。使用BlockingQueue可以简化代码，避免手动同步和管理线程状态的问题，更适合实际应用。