下面是使用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()方法来实现线程间的同步。