ArrayBlockingQueue顧名思義，是基于數組實現的阻塞隊列，阻塞隊列可以用于緩沖任務，實現生產者消費者模式，例如線程池中的工作隊列。那么怎么才能用數組實現阻塞隊列呢？
我們先從ArrayBlockingQueue的功能說起
- 首先它是一個隊列，隊列需要具備入隊、出隊的能力
- 由于是BlockingQueue，需要在隊列已滿時，對入隊的請求進行阻塞，當隊列有剩余空間時，釋放入隊請求；在隊列為空時，需要對出隊的請求進行阻塞，當隊列中有元素時，釋放出隊請求；
- 由于ArrayBlockingQueue是一個在多線程情況下使用的數據結構，需要保證它的操作的線程安全性
拆解ArrayBlockingQueue實現步驟
我們先拆解一下問題，把這個問題分成
- 用數組實現隊列
- 給隊列加上阻塞能力和保證線程安全
用數組實現隊列
如何用數組實現數據的入隊出隊操作呢，很多同學第一時間會想到，通過一個index字段存儲當前數組下一個寫入的位置。那么如何處理出隊呢，很多同學會想到出隊就是返回數組第一個元素，并且把后面所有的元素向前移動一位。
這個方案的問題在于出隊時會移動大量的元素，它的時間復雜度是O(n)，那有沒有更高效的方案呢？還有另一個循環數組的方案，我們通過兩個int字段，分別記錄下一個要入隊和下一個要出隊的元素的位置，當入隊到數組末尾時，從0開始，同樣當出隊到末尾時，也從0開始。
另外當隊列為空和隊列已滿的時候，takeIndex和putIndex都指向相同的位置，所以為了進行區分，我們可以用一個count字段存儲隊列元素數量，這樣當count=0的時候說明隊列為0，count=數組容量的時候說明隊列已滿
下面代碼展示了用數組實現隊列的具體實現。
class ArrayBlockingQueue<E> {
final Object[] items;
int takeIndex;
int putIndex;
int count;
public ArrayBlockingQueue(int capacity) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new Object[capacity];
}
private void enqueue(E e) {
Object[] items = this.items;
items[putIndex] = e;
if (++putIndex == items.length) putIndex = 0;
count++;
}
private E dequeue() {
Object[] items = this.items;
E e = (E) items[takeIndex];
items[takeIndex] = null;
if (++takeIndex == items.length) takeIndex = 0;
count--;
return e;
}
}
實現條件阻塞和線程安全
「在隊列已滿時，對入隊的請求進行阻塞，當隊列有剩余空間時，釋放入隊請求」這個需求本質上是一個條件等待的特例，寫入的條件是隊列不滿，不滿足條件的時候需要等待，直到滿足條件為止。
在Java中，實現條件等待有synchronized+Object.wait和Lock+Condition.await兩種方式，這里不用synchronized方案，是因為
- synchronized不支持interrupt
- synchronized無法支持多個條件
通過Lock和Condition的方案，還能夠保證線程安全，因為上面的環形數組實現中，線程間共享的變量有items數組、takeIndex、putIndex、count，線程安全涉及到原子性可見性重排序幾個方面，通過Lock類加鎖可以對共享變量的讀寫操作進行保護。
定義阻塞的Lock對象和Condition，條件分為不滿和不空兩個條件。
class ArrayBlockingQueue<E> {
final Object[] items;
int takeIndex;
int putIndex;
int count;
ReentrantLock lock;
private final Condition notEmpty;
private final Condition notFull;
public ArrayBlockingQueue(int capacity) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new Object[capacity];
// 創建lock對象
lock = new ReentrantLock();
// 創建非空的Condition
notEmpty = lock.newCondition();
// 創建不滿的Condition
notFull = lock.newCondition();
}
}
以入隊操作添加實現為例，能夠入隊的條件是隊列不滿，也就是count < items.length，不能入隊的條件反過來就是count == items.length。 當滿足條件后，我們就可以入隊了，入隊之后，還需要喚醒等待出隊的線程。
put方法的流程為
- 先加鎖
- 在鎖中while循環判斷條件是否滿足，不滿足調用notFull.await()，await()方法會釋放鎖，被其他線程signal喚醒后會重新搶鎖，再次獲得鎖后會繼續走到while循環判斷條件的地方。
- 如果條件已經滿足，則執行入隊操作
- 入隊完之后調用notEmpty.signal()喚醒一個等待notFull條件的線程
- finally中釋放鎖
public void put(E e) throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length)
notFull.await();
enqueue(e);
notEmpty.signal();
} finally {
lock.unlock();
}
}
方法中還有一些小細節
- put方法中，為什么要先用一個聲明一個lock局部變量呢？
ReentrantLock lock = this.lock;
這是因為如果不使用局部變量，后面所有使用實例變量的調用，在字節碼指令層面需要變成先調用aload 0獲取到this，再調用getField指令獲取字段值，再進行其他操作。而先把lock存到局部變量中，后面所有的獲取lock就可以變成一個aload xxx指令，從而節省了指令數量，也就會加快方法的執行速度。
- 為什么while循環需要放在鎖內呢？
如果不放在鎖內，則可能會出現多個線程同時看到滿足條件，進而去加鎖入隊。雖然入隊還是在臨界區，但是會出現隊列已滿，仍然在執行入隊操作的情況。這個問題和單例的double check locking中少些一個check的問題類似。
take方法是和put相對應的出隊方法，和put流程基本一致
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
E element = dequeue();
notFull.signal()
return element;
} finally {
lock.unlock();
}
}
本文使用 文章同步助手 同步
