如何在Java中使用LinkedBlockingQueue处理阻塞队列

在Java并发编程中，阻塞队列是实现生产者-消费者模型的常用工具，LinkedBlockingQueue作为基于链表实现的阻塞队列，具备 FIFO（先进先出）特性，支持有界和无界两种模式，适合处理多线程间的数据传递场景。本文将详细介绍它的核心特性、常用方法以及实际使用示例。

LinkedBlockingQueue的核心特性

LinkedBlockingQueue位于java.util.concurrent包下，实现了BlockingQueue接口，主要特性如下：

• 底层基于链表结构，默认情况下是无界队列（容量为Integer.MAX_VALUE），也可以在构造时指定固定容量实现有界队列。
• 支持阻塞的插入和获取操作：当队列满时，插入操作会阻塞等待；当队列空时，获取操作会阻塞等待。
• 采用两把独立的ReentrantLock分别控制入队和出队操作，相比单锁的阻塞队列，并发性能更好。
• 线程安全，无需额外加锁即可在多线程环境下直接使用。

常用方法分类

根据操作失败后的处理方式不同，LinkedBlockingQueue的方法可以分为以下几类：

实际使用示例

示例1：基础使用演示

下面的代码演示了LinkedBlockingQueue的基本增删查操作，以及不同方法的行为差异：

import java.util.concurrent.LinkedBlockingQueue;

public class LinkedBlockingQueueBasicDemo {
    public static void main(String[] args) {
        // 创建容量为3的有界LinkedBlockingQueue
        LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>(3);

        // 测试offer方法：队列未满时插入成功返回true
        System.out.println("插入元素A结果：" + queue.offer("A")); // 输出true
        System.out.println("插入元素B结果：" + queue.offer("B")); // 输出true
        System.out.println("插入元素C结果：" + queue.offer("C")); // 输出true

        // 队列已满时，offer返回false，不会抛出异常
        System.out.println("队列满时插入D结果：" + queue.offer("D")); // 输出false

        // 测试poll方法：队列非空时返回元素，队列空时返回null
        System.out.println("取出元素：" + queue.poll()); // 输出A
        System.out.println("取出元素：" + queue.poll()); // 输出B
        System.out.println("取出元素：" + queue.poll()); // 输出C
        System.out.println("队列空时取出元素：" + queue.poll()); // 输出null

        // 测试put和take的阻塞效果（这里因为主线程操作，不会实际阻塞，仅演示用法）
        try {
            queue.put("E"); // 队列空时无阻塞，直接插入
            String takeResult = queue.take(); // 队列非空，直接取出
            System.out.println("take取出元素：" + takeResult); // 输出E
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("线程被中断");
        }
    }
}

示例2：生产者-消费者模型实现

下面的代码模拟了典型的生产者-消费者场景，两个生产者线程向队列中放入数据，一个消费者线程从队列中取出数据处理，利用put和take的阻塞特性实现线程间的协调：

import java.util.concurrent.LinkedBlockingQueue;

public class ProducerConsumerDemo {
    // 创建容量为5的有界队列
    private static final LinkedBlockingQueue<String> QUEUE = new LinkedBlockingQueue<>(5);

    // 生产者线程任务
    static class Producer implements Runnable {
        private final String producerName;

        public Producer(String producerName) {
            this.producerName = producerName;
        }

        @Override
        public void run() {
            try {
                for (int i = 1; i <= 10; i++) {
                    String data = producerName + "-数据" + i;
                    // 队列满时put会阻塞，直到有空间
                    QUEUE.put(data);
                    System.out.println(producerName + "生产数据：" + data + "，当前队列大小：" + QUEUE.size());
                    Thread.sleep(100); // 模拟生产耗时
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println(producerName + "被中断");
            }
        }
    }

    // 消费者线程任务
    static class Consumer implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    // 队列空时take会阻塞，直到有数据
                    String data = QUEUE.take();
                    System.out.println("消费者处理数据：" + data + "，当前队列大小：" + QUEUE.size());
                    Thread.sleep(200); // 模拟处理耗时
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("消费者被中断");
            }
        }
    }

    public static void main(String[] args) {
        // 启动两个生产者线程
        new Thread(new Producer("生产者1")).start();
        new Thread(new Producer("生产者2")).start();
        // 启动一个消费者线程
        new Thread(new Consumer()).start();
    }
}

运行上述代码可以看到，当队列容量达到5时，生产者线程会阻塞等待，直到消费者取出数据腾出空间；当队列为空时，消费者线程会阻塞等待，直到生产者放入新数据，整个过程无需手动编写等待/唤醒逻辑，由LinkedBlockingQueue内部实现协调。

使用注意事项

• 如果使用无参构造创建LinkedBlockingQueue，默认容量是Integer.MAX_VALUE，如果生产速度远大于消费速度，可能会导致内存溢出，实际使用中建议根据业务场景指定合理的容量。
• 阻塞方法put和take会抛出InterruptedException，使用时需要正确处理中断异常，通常建议在捕获异常后恢复中断状态（调用Thread.currentThread().interrupt()）。
• 迭代器遍历LinkedBlockingQueue时不会锁定整个队列，因此遍历过程中如果其他线程修改了队列，可能会看到不一致的数据，如果需要强一致性的遍历，建议先通过toArray方法转换为数组再遍历。
• 和ArrayBlockingQueue相比，LinkedBlockingQueue的吞吐量通常更高，但每次插入都需要创建链表节点，内存开销相对更大，需要根据实际场景选择。

LinkedBlockingQueue阻塞队列生产者消费者模型Java并发编程线程安全修改时间：2026-05-24 13:26:05