線上程池建立的時候，需要傳一個堵塞佇列來維護需要執行的執行緒任務，其中最常用的是ArrayBlockingQueue和LinkedBlockingQueue。他們都繼承了BlockingQueue介面。

ArrayBlockingQueue

一個有邊界的堵塞佇列，內部使用了一個佇列來儲存元素，有takeIndex和putIndex來維護佇列頭和尾部的遊標。

    /** The queued items */
    //儲存元素的陣列
    final Object[] items;

    /** items index for next take, poll, peek or remove */
 

    int takeIndex;

    /** items index for next put, offer, or add */
    int putIndex;

    /** Number of elements in the queue */
    int count;

    /** Main lock guarding all access */
    //在取和存元素的時候會進行加鎖
    final ReentrantLock lock;

    /** Condition for waiting takes */
    //在take的時候，如果陣列為空，進行堵塞，直到陣列不為空
 

    private final Condition notEmpty;

    /** Condition for waiting puts */
    //在poll的時候，如果陣列滿了，進行堵塞，直到陣列有空位
    private final Condition notFull;

    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new
 
 Object[capacity];
        //使用鎖，預設的會使用ReentrantLock的公平鎖
        //公平鎖不先嚐試獲取鎖，直接放入AQS等待佇列裡，不公平鎖會先嚐試是否可以獲取鎖，失敗才會進入等待佇列（具體實現可以檢視ReentrantLock原始碼）
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

新增資料可以使用offer和put方法，兩個區別是offer是實現Queue的方法，在佇列滿時候返回false，不進行其他操作。而put是實現了父類BlockingQueue的方法，在佇列滿的時候會通過notFull.await();進行堵塞，知道佇列有空位的時候後再進行判斷。
刪除也是同理，poll是實現Queue的方法，在佇列為空的時候不進行任何操作，take是實現BlockingQueue的方法，在佇列空的的時候會進行堵塞。

    public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }
    public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            //注意這個while，要不堵塞後還是需要進行判斷
            while (count == items.length)
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }
    //取出資料
    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

當佇列新增資料的時候，先會上鎖，然後呼叫enqueue方法新增元素。
當佇列刪除資料的時候，還是會先上鎖，然後呼叫dequeue刪除元素，其中會把items[takeIndex]置為null，這樣有助於gc，防止記憶體溢位。
其中putIndex和takeIndex和最大的長度一致時，會變為0，形成一個環，使佇列可以迴圈使用。

    private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
        notEmpty.signal();
    }
        private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        notFull.signal();
        return x;
    }

LinkedBlockingQueue

LinkedBlockingQueue和ArrayBlockingQueue相比最大的不同是他可以作為一個無邊界的堵塞佇列，他的內部使用的連結串列的形式來儲存元素。

//內部定義了一個很簡單的Node節點來儲存資料。
static class Node<E> {
        E item;

        /**
         * One of:
         * - the real successor Node
         * - this Node, meaning the successor is head.next
         * - null, meaning there is no successor (this is the last node)
         */
        Node<E> next;

        Node(E x) { item = x; }
    }

其次，其內部分別定義了讀寫鎖來對寫和讀進行加鎖操作，這樣相比一個鎖的好處是細化了鎖的跨度，讀寫分離，減小了鎖的競爭。

    /** Lock held by take, poll, etc */
    private final ReentrantLock takeLock = new ReentrantLock();

    /** Wait queue for waiting takes */
    private final Condition notEmpty = takeLock.newCondition();

    /** Lock held by put, offer, etc */
    private final ReentrantLock putLock = new ReentrantLock();

    /** Wait queue for waiting puts */
    private final Condition notFull = putLock.newCondition();

思考了下為什麼ArrayBlockingQueue只用了一個鎖的？我的理解是LinkedBlockingQueue是由連結串列組成操作的分別是頭尾節點，相互競爭的關係較小。而ArrayBlockingQueue是陣列，新增和刪除都是在同一個陣列上，雖然也可以用兩個鎖但是實現上需要更多的控制。