溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
今天要講的是ArrayBlockQueue，ArrayBlockQueue是JUC提供的線程安全的有界的阻塞隊列，一看到Array，第一反應：這貨肯定和數組有關，既然是數組，那自然是有界的了，我們先來看看ArrayBlockQueue的基本使用方法，然后再看看ArrayBlockQueue的源碼。
ArrayBlockQueue基本使用
public static void main(String[] args) throws InterruptedException {
ArrayBlockingQueue<Integer> arrayBlockingQueue=new ArrayBlockingQueue(5);
arrayBlockingQueue.offer(10);
arrayBlockingQueue.offer(50);
arrayBlockingQueue.add(20);
arrayBlockingQueue.add(60);
System.out.println(arrayBlockingQueue);
System.out.println(arrayBlockingQueue.poll());
System.out.println(arrayBlockingQueue);
System.out.println(arrayBlockingQueue.take());
System.out.println(arrayBlockingQueue);
System.out.println(arrayBlockingQueue.peek());
System.out.println(arrayBlockingQueue);
}
運行結果：
代碼比較簡單，但是你肯定會有疑問
要解決上面幾個疑問，最好的辦法當然是看下源碼，通過親自閱讀源碼所產生的印象遠遠要比看視頻，看博客，死記硬背最后的結論要深刻的多。就算真的忘記了，只要再看看源碼，瞬間可以回憶起來。
ArrayBlockQueue源碼解析
構造方法
ArrayBlockQueue提供了三個構造方法，如下圖所示：
ArrayBlockingQueue(int capacity)
public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}
這是最常用的構造方法，傳入capacity，capacity是容量的意思，也就是ArrayBlockingQueue的最大長度，方法內部直接調用了第二個構造方法，傳入的第二個參數為false。
ArrayBlockingQueue(int capacity, boolean fair)
public ArrayBlockingQueue(int capacity, boolean fair) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new Object[capacity];
lock = new ReentrantLock(fair);
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}
這個構造方法接受兩個參數，分別是capacity和fair，fair是boolean類型的，代表是公平鎖，還是非公平鎖，可以看出如果我們用第一個構造方法來創建ArrayBlockingQueue的話，采用的是非公平鎖，因為公平鎖會損失一定的性能，在沒有充足的理由的情況下，是沒有必要采用公平鎖的。
方法內部做了幾件事情：
至于排他鎖和兩個條件變量是做什么用的，看到后面就明白了。
ArrayBlockingQueue(int capacity, boolean fair,Collection<? extends E> c)
public ArrayBlockingQueue(int capacity, boolean fair,
Collection<? extends E> c) {
//調用第二個構造方法，方法內部就是初始化數組，排他鎖，兩個條件變量
this(capacity, fair);
final ReentrantLock lock = this.lock;
lock.lock(); // 開啟排他鎖
try {
int i = 0;
try {
// 循環傳入的集合，把集合中的元素賦值給items數組，其中i會自增
for (E e : c) {
checkNotNull(e);
items[i++] = e;
}
} catch (ArrayIndexOutOfBoundsException ex) {
throw new IllegalArgumentException();
}
count = i;//把i賦值給count
//如果i==capacity，也就是到了最大容量，把0賦值給putIndex，否則把i賦值給putIndex
putIndex = (i == capacity) ? 0 : i;
} finally {
lock.unlock();//釋放排他鎖
}
}
看到這里，我們應該明白這個構造方法的作用是什么了，就是把傳入的集合作為ArrayBlockingQueuede初始化數據，但是我們又會有一個新的疑問：count，putIndex 是做什么用的。
offer(E e)
public boolean offer(E e) {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lock();//開啟排他鎖
try {
if (count == items.length)//如果count==items.length，返回false
return false;
else {
enqueue(e);//入隊
return true;//返回true
}
} finally {
lock.unlock();//釋放鎖
}
}
看到這里，我們應該可以明白了，ArrayBlockQueue是如何保證線程安全的，還是利用了ReentrantLock排他鎖，count就是用來保存數組的當前大小的。我們再來看看enqueue方法。
private void enqueue(E x) {
final Object[] items = this.items;
items[putIndex] = x;
if (++putIndex == items.length)
putIndex = 0;
count++;
notEmpty.signal();
}
這方法比較簡單，在代碼里面就不寫注釋了，做了如下的操作：
這里就解答了一個疑問：putIndex是做什么的，就是入隊元素的下標。
add(E e)
public boolean add(E e) {
return super.add(e);
}
public boolean add(E e) {
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
這個方法內部最終還是調用的offer方法。
put(E e)
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();//開啟響應中斷的排他鎖
try {
while (count == items.length)//如果隊列滿了，調用notFull的await
notFull.await();
enqueue(e);//入隊
} finally {
lock.unlock();//釋放排他鎖
}
}
可以看到put方法和 offer/add方法的區別了：
poll()
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return (count == 0) ? null : dequeue();
} finally {
lock.unlock();
}
}
我們來看dequeue方法：
private E dequeue() {
final Object[] items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];//獲得元素的值
items[takeIndex] = null;//把null賦值給items[takeIndex]
if (++takeIndex == items.length)//如果takeIndex自增后的值== items.length，就把0賦值給takeIndex
takeIndex = 0;
count--;
if (itrs != null)
itrs.elementDequeued();
notFull.signal();//喚醒因為調用notFull的await方法而被阻塞的線程
return x;
}
這里調用了notFull的signal方法來喚醒因為調用notFull的await方法而被阻塞的線程，那到底在哪里調用了notFull的await方法呢，還記不記得在put方法中調用了notFull的await方法，我們再看看：
while (count == items.length)
notFull.await();
當隊列滿了，就調用 notFull.await()來等待，在出隊操作中，又調用了notFull.signal()來喚醒。
take()
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return dequeue();
} finally {
lock.unlock();
}
}
這里調用了notEmpty的await方法，那么哪里調用了notEmpty的signal方法呢？在enqueue入隊方法里。
我們可以看到take和poll的區別：
peek()
public E peek() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return itemAt(takeIndex);
} finally {
lock.unlock();
}
}
final E itemAt(int i) {
return (E) items[i];
}
我們可以看到peek和poll/take的區別：
size()
public int size() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return count;
} finally {
lock.unlock();
}
}
總結
至此，ArrayBlockQueue的核心源碼就分析完畢了，我們來做一個總結：
以上所述是小編給大家介紹的ArrayBlockQueue源碼解析詳解整合，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對億速云網站的支持！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
