Java 并发包 LinkedBlockingQueue 详解

• 阻塞逻辑：队列满时调用 notFull.await()，释放锁并等待。
• 唤醒机制：入队成功后，若队列未满，通过 notFull.signal() 唤醒其他生产者线程。

offer(E e)

public boolean offer(E e) {
    if (e == null) throw new NullPointerException();
    final AtomicInteger count = this.count;
    if (count.get() == capacity) return false; // 非阻塞，直接返回失败
    int c = -1;
    Node<E> node = new Node<>(e);
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        if (count.get() < capacity) {
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity) notFull.signal();
        }
    } finally {
        putLock.unlock();
    }
    if (c == 0) signalNotEmpty();
    return c >= 0;
}

• 非阻塞特性：队列满时立即返回 false，不阻塞线程。

2. 出队操作

take()

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly(); // 获取出队锁
    try {
        while (count.get() == 0) {
            notEmpty.await(); // 队列空时阻塞
        }
        x = dequeue(); // 出队操作
        c = count.getAndDecrement();
        if (c > 1) notEmpty.signal(); // 唤醒其他消费者线程
    } finally {
        takeLock.unlock();
    }
    if (c == capacity) signalNotFull(); // 若队列之前满，唤醒生产者线程
    return x;
}

• 阻塞逻辑：队列空时调用 notEmpty.await()，释放锁并等待。
• 唤醒机制：出队成功后，若队列非空，通过 notEmpty.signal() 唤醒其他消费者线程。

poll()

public E poll() {
    final AtomicInteger count = this.count;
    if (count.get() == 0) return null; // 非阻塞，直接返回 null
    E x = null;
    int c = -1;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        if (count.get() > 0) {
            x = dequeue();
            c = count.getAndDecrement();
            if (c > 1) notEmpty.signal();
        }
    } finally {
        takeLock.unlock();
    }
    if (c == capacity) signalNotFull();
    return x;
}

• 非阻塞特性：队列空时立即返回 null，不阻塞线程。

四、线程安全与锁机制

1. 双锁分离

• putLock：控制入队操作，允许多个生产者并发插入。
• takeLock：控制出队操作，允许多个消费者并发移除。
• 优势：减少锁竞争，提升吞吐量（相比单锁的 ArrayBlockingQueue）。

2. 条件变量

• notEmpty：队列空时，消费者线程在此条件上等待。
• notFull：队列满时，生产者线程在此条件上等待。
• 唤醒策略：插入或移除元素后，通过 signal() 或 signalAll() 唤醒等待线程。

五、适用场景

1. 生产者 - 消费者模型：平衡生产者和消费者的处理速度，避免资源浪费。
2. 线程池任务队列：如 ThreadPoolExecutor 默认使用 LinkedBlockingQueue 作为任务缓冲区。
3. 数据流水线处理：在多阶段数据处理中传递数据。
4. 限流场景：通过设置容量限制防止系统过载。

六、与其他队列的对比

七、注意事项

1. 内存风险：默认无界队列可能导致内存溢出（OOM），建议生产环境指定容量。
2. 中断处理：阻塞方法（如 put()/take()）会响应中断，需捕获 InterruptedException 并处理中断状态。
3. 性能调优：高并发场景下，合理设置队列容量和线程池参数（如 corePoolSize、maximumPoolSize）。

八、源码设计细节

1. 哨兵节点：初始化时 head 和 last 均指向空节点，简化插入和删除逻辑。
2. 弱一致性迭代器：遍历时基于当前快照，允许并发修改但可能遗漏新元素。
3. 内存管理：节点通过 new 分配，依赖 GC 回收，避免手动内存管理开销。

九、总结

LinkedBlockingQueue 是 Java 并发编程中高性能阻塞队列的典范，通过双锁分离和条件变量机制，在保证线程安全的同时最大化吞吐量。适用于生产者 - 消费者模型、线程池任务队列等场景，但需注意无界队列的内存风险。理解其底层实现（如双锁、条件变量）有助于在实际工程中合理应用。