摘要：與基于數(shù)組的隊列相同，重載的構(gòu)造函數(shù)可以接受集合指定的初始值。這種隊列比基于數(shù)組阻塞隊列具有更高的吞吐量。創(chuàng)建個交易者實例，將自己出售的訂單放入隊列中，每個出售訂單都將會有隨機的交易量。要使用基于優(yōu)先級的隊列，需要提供適當?shù)谋容^器。

在阻塞隊列的幫助下，許多同步問題都可以被公式化。阻塞隊列是隊列，當線程試圖對空隊列進行出列操作，或試圖向滿的隊列中插入條目時，隊列就會阻塞。直到其他線程向隊列中放入數(shù)據(jù)時才可以移除，同樣，直到其他線程從隊列中移除條目之后才可以加入。通過使用 輪詢或等待-通知機制可以實現(xiàn)阻塞隊列。就輪詢機制來說，讀線程周期性的調(diào)用隊列的get方法，直到隊列的消息變?yōu)榭捎谩Ｖ劣诘却?通知機制，讀線程僅僅是等待隊列對象，隊列對象會在有條目時通知線程。

阻塞隊列的典型特征可以概括如下：

阻塞隊列提供了方法來向其中添加條目。這些方法的調(diào)用都是阻塞調(diào)用的，其中條目的插入必須等待，直到隊列的空間變?yōu)榭捎谩?/p>

隊列提供了方法來從中刪除條目，對這些方法的調(diào)用同樣是阻塞調(diào)用的。調(diào)用者會等待條目被放入空隊列

add和remove方法可以選擇性地為它們的等待操作提供超時并可能被中斷

put和take操作在多帶帶的線程中實現(xiàn)，從而在兩種類型的操作之間提供了良好的絕緣性

不能像阻塞隊列中插入null元素

阻塞隊列可能受容量的限制

阻塞隊列的實現(xiàn)是線程安全的，然而批量操作，比如addAll，沒有必要一定原子地執(zhí)行，

阻塞隊列在本質(zhì)上不支持“關(guān)閉”或“停止”操作，這表示沒有更多的條目可添加

LinkedBlockingQueue是通過將阻塞隊列的最大容量變?yōu)榭勺儯M而擴展了數(shù)據(jù)阻塞隊列的概念。你仍然可以在指定容量已禁止過度擴容。如果不指定容量，默認值是最大的整數(shù)值。沒有容量限制是由好處的，因為如果先飛著晚于預(yù)訂時間選取條目，生產(chǎn)者無需等待。與基于數(shù)組的隊列相同，重載的構(gòu)造函數(shù)可以接受集合指定的初始值。這種隊列比基于數(shù)組阻塞隊列具有更高的吞吐量。但同時也有較少的可預(yù)見性。除了移除操作在線性時間運行之外，隊列的大多數(shù)操作都是在常數(shù)時間內(nèi)運行的。

PriorityBlockingQueue是無界隊列，可以決定元素的優(yōu)先順序，優(yōu)先級可以由元素的自然順序或你提供的比較器來確定。依照優(yōu)先級隊列的順序，視圖插入不可比較的對象會導(dǎo)致ClassCastException異常。如果系統(tǒng)資源耗盡，雖然是無界隊列，添加操作也會失敗，

package com.guo.chap18;
import java.io.IOException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * Created by guo on 17/2/2018.
 * 基于阻塞隊列的股票交易服務(wù)器
 * 需求：
 *      1、允許交易者往隊列中添加出售訂單，也可以獲取待辦的訂單
 *      2、在任何給定的時間，如果隊列已滿，交易者就不得不等待某個位置變?yōu)榭? *      3、購買者必須等待，直到隊列中有出售訂單可用。
 *      4、為了簡化情形，假設(shè)買方總是必須購買全額數(shù)量的可供出售的股票，不可以部分購買。
 */
public class StockExchange {

    public static void main(String[] args) {
        System.out.printf("Hit Enter to terminate %n%n");
        //1、創(chuàng)建LinkedBlockingQueue實例，因為是無限容量，所以交易者可以把任何數(shù)量的訂單放入隊列中，
        //   如果使用ArrayBlockingQueue，那么將會限制每只股票擁有有限次數(shù)的交易。
        BlockingQueue orderQueue = new LinkedBlockingQueue<>();
        //2、創(chuàng)建Seller賣家實例，Seller是Runnable的實現(xiàn)類。
        Seller seller = new Seller(orderQueue);
        //3、創(chuàng)建100個交易者實例，將自己出售的訂單放入隊列中，每個出售訂單都將會有隨機的交易量。
        Thread[] sellerThread = new Thread[100];
        for (int i = 0; i < 100; i++) {
             sellerThread[i] = new Thread(seller);
             sellerThread[i].start();
        }
        //4、創(chuàng)建100個買家實例，選取待售的訂單
        Buyer buyer = new Buyer(orderQueue);
        Thread[] buyserThread = new Thread[100];
        for (int i = 0; i < 100; i++) {
            buyserThread[i] = new Thread(buyer);
            buyserThread[i].start();
        }
        try {
            //5、一旦創(chuàng)建生產(chǎn)者和消費者線程，他們會永遠保持運行，將訂單放入隊列以及從隊列中獲取訂單
            //   根據(jù)給定時間的負載情況，定期自我阻塞，終止應(yīng)用程序的方法是用戶在鍵盤上按下Enter鍵。
            while (System.in.read() != "
");
        } catch (IOException e) {
            e.printStackTrace();
        }
        //6、main函數(shù)會中斷所有正在運行的生產(chǎn)者和消費者線程，要求它們中指并退出
        System.out.println("Terminating");
        for (Thread t : sellerThread) {
            t.interrupt();
        }
        for (Thread t : buyserThread) {
            t.interrupt();
        }

    }
}

/**
 * 賣家
 * Seller類實現(xiàn)了Runnable接口并提供了以O(shè)rderQueue作為參數(shù)的構(gòu)造函數(shù)
 */
class  Seller implements Runnable {
    private BlockingQueue orderQueue;
    private boolean shutdownRequest = false;
    private static int id;
    public Seller(BlockingQueue orderQueue) {
        this.orderQueue = orderQueue;
    }
    @Override
    public void run() {
        while (shutdownRequest == false) {
            //1、在每一次迭代中，為每一次的交易量生產(chǎn)一個隨機數(shù)
            Integer quantity = (int) (Math.random() * 100);
            try {
                //2、調(diào)用put方法，將訂單放入隊列中，這是阻塞調(diào)用，只有在隊列容量有限的情況下，
                //    線程才需要等待隊列中有出現(xiàn)空的位置
                orderQueue.put(quantity);
                //3、為了方便用戶，在控制臺打印銷售訂單的詳細信息，以及用于放置銷售訂單的線程詳細信息
                System.out.println("Sell order by" + Thread.currentThread().getName() + ": " + quantity);
            } catch (InterruptedException e) {
                //4、run方法將無限期的運行，定期的向隊列中提交訂單，通過調(diào)用interrupt方法，這個線程可以被另外一個線程中斷。
                //   interrupt方法產(chǎn)生的InterruptException異常簡單的將shutdownRequest標志設(shè)置為true，將導(dǎo)致run方法無限循環(huán)終止
                shutdownRequest = true;
            }
        }
    }
}

/**
 *  買家
 *  Buyer類實現(xiàn)了Runnable接口并提供了以O(shè)rderQueue作為參數(shù)的構(gòu)造函數(shù)
 */
class Buyer implements Runnable{
    private BlockingQueue orderQueue;
    private boolean shutdownRequest = false;
    public Buyer(BlockingQueue orderQueue) {
        this.orderQueue = orderQueue;
    }
    @Override
    public void run() {
        while (shutdownRequest == false) {
            try {
                //1、run方法通過調(diào)用take方法，從隊列的頭部取出待辦的交易，
                //   如果隊列中沒有可用的訂單，take方法將阻塞，
                Integer quantity = ((Integer) orderQueue.take());
                //2、為了方便，打印訂單和線程的詳細信息
                System.out.println("Buy order by " + Thread.currentThread().getName() + ": " + quantity);
            } catch (InterruptedException e) {
                shutdownRequest = true;
            }
        }
    }
}

...
Buy order by Thread-134: 48
Buy order by Thread-134: 83
Buy order by Thread-134: 2
Buy order by Thread-134: 52
Sell order byThread-86: 90
Sell order byThread-86: 19
Sell order byThread-86: 64
Sell order byThread-86: 83
Sell order byThread-86: 27
Buy order by Thread-163: 94
Buy order by Thread-163: 74
...

當在鍵盤上按下Enter鍵使，程序終止

在這個程序中，如果沒有使用阻塞隊列，訪問非同步隊列中放置的交易時會發(fā)生競爭，每個人都會嘗試搶得低于當前市場價格出售的股票，多個交易者會選取統(tǒng)一訂單，交易之間會很混亂，由于阻塞隊列 確保了同步地訪問隊列，因此交易的完整性絕不會 受到損害。

在這個例子中使用了LinkedBlockingQueue，氣死也可以基于優(yōu)先級的隊列，這樣會自動按照交易的買價和賣價對交易進行排列，具有最好買價和最低賣價的訂單總是排在隊列的頭部。要使用基于優(yōu)先級的隊列，需要提供適當?shù)谋容^器。

1、GitHub代碼歡迎star。你們輕輕的一點，對我鼓勵特大。

2、個人認為學習語言最好的方式就是模仿、思考別人為什么這么寫。結(jié)合栗子效果更好，也能記住知識點。

3、只因為自己知識欠缺，語言組織能力不行，所以只能以這樣方式記錄。感覺效果很好。

4、本文基于《Java 7 編程高級進階》所寫，寫的非常不錯，建議大家去看看