Java代码解决生产者--消费者问题

下面是使用Java多线程以及wait()和notify()方法解决生产者-消费者问题的简单示例代码：

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

class Producer implements Runnable {
    private Queue<Integer> buffer;
    private int maxSize;

    public Producer(Queue<Integer> buffer, int maxSize) {
        this.buffer = buffer;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        int product = 0;
        while (true) {
            synchronized (buffer) {
                while (buffer.size() == maxSize) {
                    try {
                        buffer.wait(); // 等待buffer不满
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                buffer.offer(product); // 生产产品
                System.out.println("Producer produced: " + product);
                product++;
                buffer.notifyAll(); // 通知消费者可以消费
            }
        }
    }
}


class Consumer implements Runnable {
    private Queue<Integer> buffer;

    public Consumer(Queue<Integer> buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (buffer) {
                while (buffer.isEmpty()) {
                    try {
                        buffer.wait(); // 等待buffer不空
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int consumed = buffer.poll(); // 消费产品
                System.out.println("Consumer consumed: " + consumed);
                buffer.notifyAll(); // 通知生产者可以生产
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Queue<Integer> buffer = new LinkedList<>();
        int maxSize = 10;
        
        // 创建生产者和消费者线程
        Producer producer = new Producer(buffer, maxSize);
        Consumer consumer = new Consumer(buffer);
        Thread producerThread = new Thread(producer);
        Thread consumerThread = new Thread(consumer);
        
        // 启动生产者和消费者线程
        producerThread.start();
        consumerThread.start();
    }
}

上述代码中，Producer类表示生产者线程，Consumer类表示消费者线程。这两个类都实现了Runnable接口，并在run()方法中定义了线程的执行逻辑。

生产者线程在循环中检查缓冲区是否已满，如果已满则调用buffer.wait()进入等待状态，否则将产品添加到缓冲区，并通过buffer.notifyAll()通知消费者线程可以消费了。

消费者线程在循环中检查缓冲区是否为空，如果为空则调用buffer.wait()进入等待状态，否则从缓冲区中取出产品，并通过buffer.notifyAll()通知生产者线程可以生产了。

在Main类中，创建了一个线程安全的队列buffer作为缓冲区，并设定了最大容量maxSize。然后创建生产者和消费者线程，并启动它们。

这样就实现了一个简单的生产者-消费者模型，生产者不断地生产产品，消费者不断地消费产品，并通过wait()和notify()方法来实现线程间的同步。