以下是一个示例代码，展示了如何使用BlockingQueue实现一个生产者-多个消费者的模式：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ProducerConsumerExample {
    private static final int QUEUE_CAPACITY = 10;
    private static final int NUM_PRODUCERS = 1;
    private static final int NUM_CONSUMERS = 3;

    public static void main(String[] args) {
        // 创建一个容量为10的阻塞队列
        BlockingQueue queue = new LinkedBlockingQueue<>(QUEUE_CAPACITY);

        // 创建多个生产者线程
        for (int i = 0; i < NUM_PRODUCERS; i++) {
            Thread producerThread = new Thread(() -> {
                try {
                    // 模拟生产者不断地往队列中生产数据
                    for (int j = 0; j < 20; j++) {
                        int num = j + 1;
                        System.out.println("生产者生产数据: " + num);
                        queue.put(num);
                        Thread.sleep(100);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            producerThread.start();
        }

        // 创建多个消费者线程
        for (int i = 0; i < NUM_CONSUMERS; i++) {
            Thread consumerThread = new Thread(() -> {
                try {
                    // 模拟消费者不断地从队列中消费数据
                    while (true) {
                        int num = queue.take();
                        System.out.println("消费者消费数据: " + num);
                        Thread.sleep(500);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            consumerThread.start();
        }
    }
}

这个例子中，使用LinkedBlockingQueue作为队列，容量为10。创建了一个生产者线程和三个消费者线程。

生产者线程通过queue.put(num)将数据放入队列中，消费者线程通过queue.take()从队列中取出数据。由于队列是阻塞队列，当队列空时，消费者线程将阻塞等待直到队列中有数据可供消费。同样地，当队列满时，生产者线程将阻塞等待直到队列有空闲位置可供生产。

通过使用BlockingQueue，我们可以实现一个线程安全的生产者-消费者模式，保证了数据的正确传递和线程之间的同步。