宣告

該系列文章只是記錄本人回顧java多執行緒程式設計時候記錄的筆記。文中所用語言並非嚴謹的專業術語(太嚴謹的術語其實本人也不會……)。難免有理解偏差的地方，歡迎指正。
另外，大神請繞路。不喜勿噴。
畢竟好記性不如爛筆頭嘛，而且許多東西只要不是你經常用的最終都會一丟丟一丟丟地給忘記。

初看之下，阻塞佇列似乎和多執行緒沒有多大關係。但是平時使用阻塞佇列的場景往往是和執行緒相關的。所以，此處將阻塞佇列也歸入java多執行緒的分類。

1 什麼是阻塞佇列

說白了，阻塞佇列還是一個佇列(FIFO)。至於佇列的概念就不多說了。
阻塞佇列和普通佇列的區別就在阻塞這個詞。

阻塞的意思，可以這麼理解：

• 當嘗試隊列出隊操作時，若佇列已經是空的，則調用出隊操作的執行緒將被阻塞，直到佇列有可用元素為止
• 當嘗試佇列入隊操作時，若佇列已經是滿的，則呼叫入隊操作的執行緒將被阻塞，直到佇列不再是滿的為止

2 JDK提供的阻塞佇列

2.1 JDK內建的阻塞佇列

• ArrayBlockingQueue: 陣列結構的有界阻塞佇列
• LinkedBlockingQueue: 連結串列結構的有界阻塞佇列
• LinkedTransferQueue: 連結串列結構的無界阻塞佇列
• LinkedBlockingDeque: 連結串列結構的雙向阻塞佇列
• PriorityBlockingQueue: 支援按優先順序
  排序的無界阻塞佇列
• DelayQueue: 使用優先順序佇列(PriorityQueue)實現的阻塞佇列，優先佇列的比較基準值是時間
• SynchronousQueue: 不知道怎麼描述這個佇列,因為他並不真正儲存元素。每個插入操作必須等待另一個執行緒的移除操作，同樣一個移除操作都等待另一個執行緒的插入操作。

2.2 阻塞佇列不可用時的處理方式

此處要說的是，佇列在特殊情況下的出隊入隊操作的處理。
比如在佇列為空或者佇列已經滿了的時候不同的阻塞佇列實現或者不同的方法會有不同的處理方式。

對這種特殊情況的處理，大致有以下一些方法:

• 拋異常
  
  • 佇列為空時進行出隊操作,可能會有NoSuchElementException
  • 佇列已滿時進行入隊操作,可能會有IllegalStateException
• 返回特殊值
  
  • 丟擲NoSuchElementException,可以返回null代替表示佇列為空
  • 丟擲IllegalStateException,可以返回false表示入隊失敗
• 一直阻塞
  
  • 佇列為空時進行出隊操作,進行出隊操作的執行緒將被阻塞,直至佇列可用
  • 佇列已滿時進行入隊操作,進行入隊操作的執行緒將被阻塞,直至佇列可用
• 超時退出
  
  • 佇列為空時進行出隊操作,進行出隊操作的執行緒將被阻塞,直至超時退出(執行緒也會退出)
  • 佇列已滿時進行入隊操作,進行入隊操作的執行緒將被阻塞,直至超時退出(執行緒也會退出)

以下圖片是來自《Java併發程式設計的藝術》一書中的總結:

3 使用示例

以上介紹的七種JDK內建的阻塞佇列，各有各的使用場景，一篇文章很難介紹清楚。
以後會抽空補全各種阻塞佇列的使用場景示例。

和上篇文章的不同之處在於，此處使用阻塞佇列來代替上篇文章中簡單實現的一個數據結構棧。
Container類的實現修改成了下面的樣子:

public static class Container {
    private ArrayBlockingQueue<Product> products;

    public Container(int size) {
        this.products = new ArrayBlockingQueue<>(size);
    }

    public void put(Product product) {
        try {
            this.products.put(product);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public Product get() {
        try {
            return this.products.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

完整的程式碼示例如下:

import java.util.concurrent.ArrayBlockingQueue;

public class ProducerConsumerByLockingQueue {

    public static void main(String[] args) {
        Container container = new Container(5);
        for (int i = 0; i < 10; i++) {
            new Thread(new Producer(container), "P-" + i).start();
            new Thread(new Consumer(container), "C-" + i).start();
        }
    }

    public static class Product {
        private String name;

        public Product(String name) {
            super();
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "[name=" + name + "]";
        }

    }

    public static class Container {
        private ArrayBlockingQueue<Product> products;

        public Container(int size) {
            this.products = new ArrayBlockingQueue<>(size);
        }

        public void put(Product product) {
            try {
                this.products.put(product);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public Product get() {
            try {
                return this.products.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

    public static class Producer implements Runnable {

        private Container container;

        public Producer(Container container) {
            super();
            this.container = container;
        }

        @Override
        public void run() {
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                Product p = new Product(Thread.currentThread().getName() + "_" + i);
                this.container.put(p);
                System.out.println("生產者[" + Thread.currentThread().getName() + "]生產>>>>>>:" + p);
                try {
                    Thread.sleep((long) (Math.random() * 1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public static class Consumer implements Runnable {

        private Container container;

        public Consumer(Container container) {
            super();
            this.container = container;
        }

        @Override
        public void run() {
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                Product product = this.container.get();
                System.out.println("消費者[" + Thread.currentThread().getName() + "]消費<<<<<<:" + product);
                try {
                    Thread.sleep((long) (Math.random() * 2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

參考資料

• 《java併發程式設計的藝術》