Java 並發容器深度解析：BlockingQueue 家族全景圖

前言：為什麼需要並發隊列？

在多線程生產者-消費者模型中，傳統集合配合 wait/notify 實現同步既繁瑣又易出錯。JDK 5.0 引入 java.util.concurrent 包，提供了線程安全、高效能的並發容器。本文聚焦 BlockingQueue 及其核心實現類，剖析源碼級設計細節。

BlockingQueue 體系總覽

核心實現類：

• ArrayBlockingQueue：有界數組隊列，單鎖雙條件
• LinkedBlockingQueue：可選有界鏈表隊列，雙鎖分離
• PriorityBlockingQueue：無界優先級隊列，單鎖
• DelayQueue：延遲隊列，基於 PriorityQueue
• LinkedBlockingDeque：雙端阻塞隊列

BlockingQueue 接口契約

四組方法對應不同阻塞語義：

ArrayBlockingQueue：有界數組隊列深度剖析

核心字段

final Object[] items;      // 存儲元素的數組
int takeIndex;             // 下一次取元素的索引
int putIndex;              // 下一次放元素的索引
int count;                 // 當前元素數量
final ReentrantLock lock;  // 獨佔鎖（公平/非公平可選）
private final Condition notEmpty;  // 非空條件
private final Condition notFull;   // 非滿條件

三種插入方法對比

// 1. offer(e) - 非阻塞，滿則返回 false
public boolean offer(E e) {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        if (count == items.length) return false;
        insert(e);
        return true;
    } finally {
        lock.unlock();
    }
}

// 2. put(e) - 阻塞直到有空位
public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == items.length)
            notFull.await();  // 釋放鎖並進入等待
        insert(e);
    } finally {
        lock.unlock();
    }
}

// 3. offer(e, timeout, unit) - 定時阻塞
public boolean offer(E e, long timeout, TimeUnit unit) 
        throws InterruptedException {
    // ... 使用 notFull.awaitNanos(nanos) 實現超時等待
}

環形數組機制

private void insert(E x) {
    items[putIndex] = x;
    putIndex = inc(putIndex);  // 環形增長：(++i == items.length) ? 0 : i
    ++count;
    notEmpty.signal();  // 喚醒一個等待取元素的線程
}

private E extract() {
    final E[] items = this.items;
    E x = items[takeIndex];
    items[takeIndex] = null;  // GC 友好
    takeIndex = inc(takeIndex);
    --count;
    notFull.signal();  // 喚醒一個等待放元素的線程
    return x;
}

Condition 實現原理

Condition 依賴 AbstractQueuedSynchronizer 內部類 ConditionObject。await() 流程：

1. 創建條件等待節點加入等待隊列
2. 完全釋放鎖（fullyRelease）
3. LockSupport.park 掛起線程
4. 被 signal() 喚醒後，重新競爭鎖（acquireQueued）

這保證了 await/signal 必須在鎖保護下執行，享受重入特性。

LinkedBlockingQueue：雙鎖分離的鏈表隊列

• 默認容量 Integer.MAX_VALUE（無界）
• 兩把鎖：putLock（寫）、takeLock（讀）
• 兩個條件：notFull、notEmpty
• 需同時加鎖的操作（remove、toArray 等）按固定順序 putLock → takeLock 避免死鎖

private final PriorityQueue<E> q;      // 底層優先級隊列
private final ReentrantLock lock = new ReentrantLock(true);  // 公平鎖
private final Condition notEmpty = lock.newCondition();