java.util.concurrent系列之--ArrayBlockingQueue

1、ArrayBlockingQueue介紹

ArrayBlockingQueue是數組實現的線程安全的有界的阻塞隊列。 線程安全是指，ArrayBlockingQueue內部經過「互斥鎖」保護競爭資源，實現了多線程對競爭資源的互斥訪問。而有界，則是指ArrayBlockingQueue對應的數組是有界限的。 阻塞隊列，是指多線程訪問競爭資源時，當競爭資源已被某線程獲取時，其它要獲取該資源的線程須要阻塞等待；並且，ArrayBlockingQueue是按 FIFO（先進先出）原則對元素進行排序，元素都是從尾部插入到隊列，從頭部開始返回。

注意：ArrayBlockingQueue不一樣於ConcurrentLinkedQueue，ArrayBlockingQueue是數組實現的，而且是有界限的；而ConcurrentLinkedQueue是鏈表實現的，是無界限的。

2、 ArrayBlockingQueue原理和數據結構

說明：

1. ArrayBlockingQueue繼承於AbstractQueue，而且它實現了BlockingQueue接口。

2. ArrayBlockingQueue內部是經過Object[]數組保存數據的，也就是說ArrayBlockingQueue本質上是

經過數組實現的。ArrayBlockingQueue的大小，即數組的容量是建立ArrayBlockingQueue時指定的。

3. ArrayBlockingQueue與ReentrantLock是組合關係，ArrayBlockingQueue中包含一個ReentrantLock

對象(lock)。ReentrantLock是可重入的互斥鎖，ArrayBlockingQueue就是根據該互斥鎖實現「多線程對競爭

資源的互斥訪問」。並且，ReentrantLock分爲公平鎖和非公平鎖，關於具體使用公平鎖仍是非公平鎖，在創

建ArrayBlockingQueue時能夠指定；並且，ArrayBlockingQueue默認會使用非公平鎖。

4. ArrayBlockingQueue與Condition是組合關係，ArrayBlockingQueue中包含兩個Condition對象

(notEmpty和notFull)。並且，Condition又依賴於ArrayBlockingQueue而存在，經過Condition能夠實現對

ArrayBlockingQueue的更精確的訪問 --

(01)若某線程(線程A)要取數據時，數組正好爲空，則該線程會執行notEmpty.await()進行等待；當其它某個

線程(線程B)向數組中插入了數據以後，會調用notEmpty.signal()喚

醒「notEmpty上的等待線程」。此時，線程A會被喚醒從而得以繼續運行。

(02)若某線程(線程H)要插入數據時，數組已滿，則該線程會它執行notFull.await()進行等待；當其它某個線

程(線程I)取出數據以後，會調用notFull.signal()喚醒「notFull上的等待線程」。此時，線程H就會被喚醒從而得

以繼續運行。

3、ArrayBlockingQueue函數列表

// 建立一個帶有給定的（固定）容量和默認訪問策略的 ArrayBlockingQueue。
ArrayBlockingQueue(int capacity)

// 建立一個具備給定的（固定）容量和指定訪問策略的 ArrayBlockingQueue。
ArrayBlockingQueue(int capacity, boolean fair)

// 建立一個具備給定的（固定）容量和指定訪問策略的 ArrayBlockingQueue，它最初包含給定 collection 的元素，並以 collection 迭代器的遍歷順序添加元素。
ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)

// 將指定的元素插入到此隊列的尾部（若是當即可行且不會超過該隊列的容量），在成功時返回 true，若是此隊列已滿，則拋出 IllegalStateException。
boolean add(E e)

// 自動移除此隊列中的全部元素。
void clear()

// 若是此隊列包含指定的元素，則返回 true。
boolean contains(Object o)

// 移除此隊列中全部可用的元素，並將它們添加到給定 collection 中。
int drainTo(Collection<? super E> c)

// 最多今後隊列中移除給定數量的可用元素，並將這些元素添加到給定 collection 中。
int drainTo(Collection<? super E> c, int maxElements)

// 返回在此隊列中的元素上按適當順序進行迭代的迭代器。
Iterator<E> iterator()

// 將指定的元素插入到此隊列的尾部（若是當即可行且不會超過該隊列的容量），在成功時返回 true，若是此隊列已滿，則返回 false。
boolean offer(E e)

// 將指定的元素插入此隊列的尾部，若是該隊列已滿，則在到達指定的等待時間以前等待可用的空間。
boolean offer(E e, long timeout, TimeUnit unit)

// 獲取但不移除此隊列的頭；若是此隊列爲空，則返回 null。
E peek()

// 獲取並移除此隊列的頭，若是此隊列爲空，則返回 null。
E poll()

// 獲取並移除此隊列的頭部，在指定的等待時間前等待可用的元素（若是有必要）。
E poll(long timeout, TimeUnit unit)

// 將指定的元素插入此隊列的尾部，若是該隊列已滿，則等待可用的空間。
void put(E e)

// 返回在無阻塞的理想狀況下（不存在內存或資源約束）此隊列能接受的其餘元素數量。
int remainingCapacity()

// 今後隊列中移除指定元素的單個實例（若是存在）。
boolean remove(Object o)

// 返回此隊列中元素的數量。
int size()

// 獲取並移除此隊列的頭部，在元素變得可用以前一直等待（若是有必要）。
E take()

// 返回一個按適當順序包含此隊列中全部元素的數組。
Object[] toArray()

// 返回一個按適當順序包含此隊列中全部元素的數組；返回數組的運行時類型是指定數組的運行時類型。
<T> T[] toArray(T[] a)

// 返回此 collection 的字符串表示形式。
String toString()

4、ArrayBlockingQueue示例

import java.util.*;
import java.util.concurrent.*;

/*
 *   ArrayBlockingQueue是「線程安全」的隊列，而LinkedList是非線程安全的。
 *
 *   下面是「多個線程同時操做而且遍歷queue」的示例
 *   (01) 當queue是ArrayBlockingQueue對象時，程序能正常運行。
 *   (02) 當queue是LinkedList對象時，程序會產生ConcurrentModificationException異常。
 *
 * @author skywang
 */
public class ArrayBlockingQueueDemo1{

    // TODO: queue是LinkedList對象時，程序會出錯。
    //private static Queue<String> queue = new LinkedList<String>();
    private static Queue<String> queue = new ArrayBlockingQueue<String>(20);
    public static void main(String[] args) {
    
        // 同時啓動兩個線程對queue進行操做！
        new MyThread("ta").start();
        new MyThread("tb").start();
    }

    private static void printAll() {
        String value;
        Iterator iter = queue.iterator();
        while(iter.hasNext()) {
            value = (String)iter.next();
            System.out.print(value+", ");
        }
        System.out.println();
    }

    private static class MyThread extends Thread {
        MyThread(String name) {
            super(name);
        }
        @Override
        public void run() {
                int i = 0;
            while (i++ < 6) {
                // 「線程名」 + "-" + "序號"
                String val = Thread.currentThread().getName()+i;
                queue.add(val);
                // 經過「Iterator」遍歷queue。
                printAll();
            }
        }
    }
}

打印結果：

ta1, 
ta1, ta2, 
ta1, ta2, ta3, 
ta1, ta2, ta3, ta4, 
ta1, ta2, ta3, ta4, ta5, 
ta1, ta2, ta3, ta4, ta5, ta6, 
ta1, ta2, ta3, ta4, ta5, ta6, tb1, 
ta1, ta2, ta3, ta4, ta5, ta6, tb1, tb2, 
ta1, ta2, ta3, ta4, ta5, ta6, tb1, tb2, tb3, 
ta1, ta2, ta3, ta4, ta5, ta6, tb1, tb2, tb3, tb4, 
ta1, ta2, ta3, ta4, ta5, ta6, tb1, tb2, tb3, tb4, tb5, 
ta1, ta2, ta3, ta4, ta5, ta6, tb1, tb2, tb3, tb4, tb5, tb6,

5、參考文章

http://www.cnblogs.com/skywang12345/p/3498652.html