Java 多线程：生产者-消费者模式实现示例

下面是一个简单的 Java 多线程程序，其中包含一个生产者线程和多个消费者线程：

import java.util.LinkedList;

public class ProducerConsumerExample {

    public static void main(String[] args) {
        LinkedList<Integer> buffer = new LinkedList<>();
        int maxSize = 10;
        Thread producerThread = new Thread(new Producer(buffer, maxSize));
        Thread consumerThread1 = new Thread(new Consumer(buffer));
        Thread consumerThread2 = new Thread(new Consumer(buffer));
        Thread consumerThread3 = new Thread(new Consumer(buffer));
        producerThread.start();
        consumerThread1.start();
        consumerThread2.start();
        consumerThread3.start();
    }
}

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

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

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            synchronized (buffer) {
                while (buffer.size() == maxSize) {
                    try {
                        System.out.println('Buffer is full, waiting for consumers...');
                        buffer.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                buffer.add(i);
                System.out.println('Produced: ' + i);
                buffer.notifyAll();
            }
        }
    }
}

class Consumer implements Runnable {
    private final LinkedList<Integer> buffer;

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

    @Override
    public void run() {
        while (true) {
            synchronized (buffer) {
                while (buffer.isEmpty()) {
                    try {
                        System.out.println('Buffer is empty, waiting for producers...');
                        buffer.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int value = buffer.removeFirst();
                System.out.println('Consumed: ' + value);
                buffer.notifyAll();
            }
        }
    }
}

在这个例子中，我们创建了一个名为 ProducerConsumerExample 的类，它包含了一个名为 main 的方法，该方法启动了一个生产者线程和多个消费者线程。

生产者线程和消费者线程都是通过实现 Runnable 接口来定义的。生产者线程在一个循环中不断地将数字加入到一个名为 buffer 的链表中，如果链表已经达到了最大长度，则线程会进入等待状态，直到消费者线程取走了一些数字，才会继续往链表中添加数字。

消费者线程在一个循环中不断地从 buffer 链表中取出数字，如果链表已经为空，则线程会进入等待状态，直到生产者线程将更多数字加入到链表中，才会继续取出数字。

为了让生产者线程和消费者线程之间能够正确地同步，我们使用了 synchronized 关键字来锁定 buffer 对象，并使用 wait() 和 notifyAll() 方法来实现线程之间的等待和通知机制。

在这个程序中，我们仅仅使用了一个简单的链表来模拟生产者和消费者之间的通信，实际上，在实际的多线程应用中，我们可能需要使用更加复杂的数据结构和算法来实现高效的线程同步和通信。