(轉)Java併發編程：阻塞隊列

時間 2019-12-14

標籤 java 併發編程阻塞隊列欄目 Java 简体版

原文原文鏈接

原文地址：html

http://www.cnblogs.com/dolphin0520/p/3932906.htmljava

一.幾種主要的阻塞隊列

　　自從Java 1.5以後，在java.util.concurrent包下提供了若干個阻塞隊列，主要有如下幾個：編程

　　ArrayBlockingQueue：基於數組實現的一個阻塞隊列，在建立ArrayBlockingQueue對象時必須制定容量大小。而且能夠指定公平性與非公平性，默認狀況下爲非公平的，即不保證等待時間最長的隊列最優先可以訪問隊列。數組

　　LinkedBlockingQueue：基於鏈表實現的一個阻塞隊列，在建立LinkedBlockingQueue對象時若是不指定容量大小，則默認大小爲Integer.MAX_VALUE。併發

　　PriorityBlockingQueue：以上2種隊列都是先進先出隊列，而PriorityBlockingQueue卻不是，它會按照元素的優先級對元素進行排序，按照優先級順序出隊，每次出隊的元素都是優先級最高的元素。注意，此阻塞隊列爲無界阻塞隊列，即容量沒有上限（經過源碼就能夠知道，它沒有容器滿的信號標誌），前面2種都是有界隊列。socket

　　DelayQueue：基於PriorityQueue，一種延時阻塞隊列，DelayQueue中的元素只有當其指定的延遲時間到了，纔可以從隊列中獲取到該元素。DelayQueue也是一個無界隊列，所以往隊列中插入數據的操做（生產者）永遠不會被阻塞，而只有獲取數據的操做（消費者）纔會被阻塞。ide

二.阻塞隊列中的方法 VS 非阻塞隊列中的方法

1.非阻塞隊列中的幾個主要方法：this

　　add(E e):將元素e插入到隊列末尾，若是插入成功，則返回true；若是插入失敗（即隊列已滿），則會拋出異常；spa

　　remove()：移除隊首元素，若移除成功，則返回true；若是移除失敗（隊列爲空），則會拋出異常；.net

　　offer(E e)：將元素e插入到隊列末尾，若是插入成功，則返回true；若是插入失敗（即隊列已滿），則返回false；

　　poll()：移除並獲取隊首元素，若成功，則返回隊首元素；不然返回null；

　　peek()：獲取隊首元素，若成功，則返回隊首元素；不然返回null

　　對於非阻塞隊列，通常狀況下建議使用offer、poll和peek三個方法，不建議使用add和remove方法。由於使用offer、poll和peek三個方法能夠經過返回值判斷操做成功與否，而使用add和remove方法卻不能達到這樣的效果。注意，非阻塞隊列中的方法都沒有進行同步措施。

2.阻塞隊列中的幾個主要方法：

　　阻塞隊列包括了非阻塞隊列中的大部分方法，上面列舉的5個方法在阻塞隊列中都存在，可是要注意這5個方法在阻塞隊列中都進行了同步措施。除此以外，阻塞隊列提供了另外4個很是有用的方法：

　　put(E e)

　　take()

　　offer(E e,long timeout, TimeUnit unit)

　　poll(long timeout, TimeUnit unit)

　　put方法用來向隊尾存入元素，若是隊列滿，則等待；

　　take方法用來從隊首取元素，若是隊列爲空，則等待；

　　offer方法用來向隊尾存入元素，若是隊列滿，則等待必定的時間，當時間期限達到時，若是尚未插入成功，則返回false；不然返回true；

　　poll方法用來從隊首取元素，若是隊列空，則等待必定的時間，當時間期限達到時，若是取到，則返回null；不然返回取得的元素；

三.阻塞隊列的實現原理

　　前面談到了非阻塞隊列和阻塞隊列中經常使用的方法，下面來探討阻塞隊列的實現原理，本文以ArrayBlockingQueue爲例，其餘阻塞隊列實現原理可能和ArrayBlockingQueue有一些差異，可是大致思路應該相似，有興趣的朋友可自行查看其餘阻塞隊列的實現源碼。

　　首先看一下ArrayBlockingQueue類中的幾個成員變量：

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
 
private static final long serialVersionUID = -817911632652898426L;
 
/** The queued items  */
private final E[] items;
/** items index for next take, poll or remove */
private int takeIndex;
/** items index for next put, offer, or add. */
private int putIndex;
/** Number of items in the queue */
private int count;
 
/*
* Concurrency control uses the classic two-condition algorithm
* found in any textbook.
*/
 
/** Main lock guarding all access */
private final ReentrantLock lock;
/** Condition for waiting takes */
private final Condition notEmpty;
/** Condition for waiting puts */
private final Condition notFull;
}

能夠看出，ArrayBlockingQueue中用來存儲元素的其實是一個數組，takeIndex和putIndex分別表示隊首元素和隊尾元素的下標，count表示隊列中元素的個數。

lock是一個可重入鎖，notEmpty和notFull是等待條件。

下面看一下ArrayBlockingQueue的構造器，構造器有三個重載版本：

public ArrayBlockingQueue(int capacity) {
}
public ArrayBlockingQueue(int capacity, boolean fair) {
 
}
public ArrayBlockingQueue(int capacity, boolean fair,
                          Collection<? extends E> c) {
}

第一個構造器只有一個參數用來指定容量，第二個構造器能夠指定容量和公平性，第三個構造器能夠指定容量、公平性以及用另一個集合進行初始化。

而後看它的兩個關鍵方法的實現：put()和take()：

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    final E[] items = this.items;
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        try {
            while (count == items.length)
                notFull.await();
        } catch (InterruptedException ie) {
            notFull.signal(); // propagate to non-interrupted thread
            throw ie;
        }
        insert(e);
    } finally {
        lock.unlock();
    }
}

從put方法的實現能夠看出，它先獲取了鎖，而且獲取的是可中斷鎖，而後判斷當前元素個數是否等於數組的長度，若是相等，則調用notFull.await()進行等待，若是捕獲到中斷異常，則喚醒線程並拋出異常。

當被其餘線程喚醒時，經過insert(e)方法插入元素，最後解鎖。

咱們看一下insert方法的實現：

private void insert(E x) {
    items[putIndex] = x;
    putIndex = inc(putIndex);
    ++count;
    notEmpty.signal();
}

它是一個private方法，插入成功後，經過notEmpty喚醒正在等待取元素的線程。

下面是take()方法的實現：

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        try {
            while (count == 0)
                notEmpty.await();
        } catch (InterruptedException ie) {
            notEmpty.signal(); // propagate to non-interrupted thread
            throw ie;
        }
        E x = extract();
        return x;
    } finally {
        lock.unlock();
    }
}

跟put方法實現很相似，只不過put方法等待的是notFull信號，而take方法等待的是notEmpty信號。在take方法中，若是能夠取元素，則經過extract方法取得元素，下面是extract方法的實現：

private E extract() {
    final E[] items = this.items;
    E x = items[takeIndex];
    items[takeIndex] = null;
    takeIndex = inc(takeIndex);
    --count;
    notFull.signal();
    return x;
}

跟insert方法也很相似。

其實從這裏你們應該明白了阻塞隊列的實現原理，事實它和咱們用Object.wait()、Object.notify()和非阻塞隊列實現生產者-消費者的思路相似，只不過它把這些工做一塊兒集成到了阻塞隊列中實現。

四.示例和使用場景

　　下面先使用Object.wait()和Object.notify()、非阻塞隊列實現生產者-消費者模式：

public class Test {
    private int queueSize = 10;
    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
     
    public static void main(String[] args)  {
        Test test = new Test();
        Producer producer = test.new Producer();
        Consumer consumer = test.new Consumer();
         
        producer.start();
        consumer.start();
    }
     
    class Consumer extends Thread{
         
        @Override
        public void run() {
            consume();
        }
         
        private void consume() {
            while(true){
                synchronized (queue) {
                    while(queue.size() == 0){
                        try {
                            System.out.println("隊列空，等待數據");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notify();
                        }
                    }
                    queue.poll();          //每次移走隊首元素
                    queue.notify();
                    System.out.println("從隊列取走一個元素，隊列剩餘"+queue.size()+"個元素");
                }
            }
        }
    }
     
    class Producer extends Thread{
         
        @Override
        public void run() {
            produce();
        }
         
        private void produce() {
            while(true){
                synchronized (queue) {
                    while(queue.size() == queueSize){
                        try {
                            System.out.println("隊列滿，等待有空餘空間");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notify();
                        }
                    }
                    queue.offer(1);        //每次插入一個元素
                    queue.notify();
                    System.out.println("向隊列取中插入一個元素，隊列剩餘空間："+(queueSize-queue.size()));
                }
            }
        }
    }
}

這個是經典的生產者-消費者模式，經過阻塞隊列和Object.wait()和Object.notify()實現，wait()和notify()主要用來實現線程間通訊。

具體的線程間通訊方式（wait和notify的使用）在後續問章中會講述到。

下面是使用阻塞隊列實現的生產者-消費者模式：

public class Test {
    private int queueSize = 10;
    private ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(queueSize);
     
    public static void main(String[] args)  {
        Test test = new Test();
        Producer producer = test.new Producer();
        Consumer consumer = test.new Consumer();
         
        producer.start();
        consumer.start();
    }
     
    class Consumer extends Thread{
         
        @Override
        public void run() {
            consume();
        }
         
        private void consume() {
            while(true){
                try {
                    queue.take();
                    System.out.println("從隊列取走一個元素，隊列剩餘"+queue.size()+"個元素");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
     
    class Producer extends Thread{
         
        @Override
        public void run() {
            produce();
        }
         
        private void produce() {
            while(true){
                try {
                    queue.put(1);
                    System.out.println("向隊列取中插入一個元素，隊列剩餘空間："+(queueSize-queue.size()));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}