java实现生产者和消费者问题(附完整源码)

生产者和消费者问题是一个经典的多线程同步问题，下面是 Java 实现的示例代码：

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

public class ProducerConsumerExample {

    public static void main(String[] args) {
        Queue<Integer> buffer = new LinkedList<>();
        int maxSize = 10;

        Thread producer = new Thread(new Producer(buffer, maxSize));
        Thread consumer = new Thread(new Consumer(buffer));

        producer.start();
        consumer.start();
    }
}

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

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

    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                produce(i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void produce(int i) throws InterruptedException {
        synchronized (buffer) {
            while (buffer.size() == maxSize) {
                System.out.println("Buffer is full, waiting...");
                buffer.wait();
            }
            buffer.add(i);
            System.out.println("Produced: " + i);
            buffer.notifyAll();
        }
    }
}

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

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

    public void run() {
        while (true) {
            try {
                consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void consume() throws InterruptedException {
        synchronized (buffer) {
            while (buffer.isEmpty()) {
                System.out.println("Buffer is empty, waiting...");
                buffer.wait();
            }
            int value = buffer.poll();
            System.out.println("Consumed: " + value);
            buffer.notifyAll();
        }
        Thread.sleep(1000);
    }
}

这段代码中，Producer 是生产者线程，Consumer 是消费者线程，它们共享一个 buffer 队列，生产者不断往队列里添加元素，直到队列满了就等待，消费者不断从队列里取元素，直到队列为空就等待。注意到 buffer 上的锁的使用，以及 wait() 和 notifyAll() 的调用，这些都是多线程同步的基本操作。

以上是示例代码，仅供参考。