Java实现消费者生产者问题

在Java中，我们可以使用多线程和共享队列来实现消费者生产者问题。以下是一个简单的示例代码：

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

public class ProducerConsumer {
    private Queue<Integer> queue = new LinkedList<>();
    private final int MAX_SIZE = 10;

    public void start() {
        Thread producerThread = new Thread(new Producer());
        Thread consumerThread = new Thread(new Consumer());
        producerThread.start();
        consumerThread.start();
    }

    private class Producer implements Runnable {
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == MAX_SIZE) {
                        try {
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int data = (int) (Math.random() * 100);
                    queue.offer(data);
                    System.out.println("Producer produce " + data);
                    queue.notifyAll();
                }
            }
        }
    }

    private class Consumer implements Runnable {
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.isEmpty()) {
                        try {
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int data = queue.poll();
                    System.out.println("Consumer consume " + data);
                    queue.notifyAll();
                }
            }
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();
        pc.start();
    }
}

在这个示例中，我们使用了一个LinkedList作为共享队列，生产者线程不断地往队列中添加数据，如果队列已满，则等待。消费者线程不断地从队列中取出数据，如果队列为空，则等待。每次生产者添加数据或消费者取出数据时，都需要发送notifyAll()方法的信号，以唤醒等待在队列上的线程。由于生产者和消费者线程都会访问到共享队列，因此需要使用synchronized关键字来实现线程的同步和互斥。