BlockingQueue介面定義了一種阻塞的FIFO queue，每一個BlockingQueue都有一個容量，讓容量滿時往BlockingQueue中新增資料時會造成阻塞，當容量為空時取元素操作會阻塞。

ArrayBlockingQueue是一個由陣列支援的有界阻塞佇列。在讀寫操作上都需要鎖住整個容器，因此吞吐量與一般的實現是相似的，適合於實現“生產者消費者”模式。

LinkedBlockingQueue是基於連結串列的阻塞佇列，同ArrayListBlockingQueue類似，其內部也維持著一個數據緩衝佇列（該佇列由一個連結串列構成），當生產者往佇列中放入一個數據時，佇列會

從生產者手中獲取資料，並快取在佇列內部，

阻塞生產者佇列，直到消費者從佇列中消費掉一份資料，生產者執行緒會被喚醒，反之對於消費者這端的處理也基於同樣的原理。而LinkedBlockingQueue之所以能夠高效

的處理併發資料，還因為其對於生產者端和消費者端分別採用了獨立的鎖來控制資料同步，這也意味著在高併發的情況下生產者和消費者可以並行地操作佇列中的資料，

以此來提高整個佇列的併發效能。

ArrayBlockingQueue和LinkedBlockingQueue的區別：

1. 佇列中鎖的實現不同

    ArrayBlockingQueue實現的佇列中的鎖是沒有分離的，即生產和消費用的是同一個鎖；

    LinkedBlockingQueue實現的佇列中的鎖是分離的，即生產用的是putLock，消費是takeLock

2. 在生產或消費時操作不同

    ArrayBlockingQueue實現的佇列中在生產和消費的時候，是直接將列舉物件插入或移除的；

    LinkedBlockingQueue實現的佇列中在生產和消費的時候，需要把列舉物件轉換為Node<E>進行插入或移除，會影響效能

3. 佇列大小初始化方式不同

    ArrayBlockingQueue實現的佇列中必須指定佇列的大小；

    LinkedBlockingQueue實現的佇列中可以不指定佇列的大小，但是預設是Integer.MAX_VALUE

常用API：

offer

將元素插入佇列，成功返回true，如果當前沒有可用的空間，則返回false

offer(E e, long timeout, TimeUnit unit) 

將元素插入佇列，在到達指定的等待時間前等待可用的空間

E poll(long timeout, TimeUnit unit) 

獲取並移除佇列的頭部，在指定的等待時間前等待可用的元素

void put(E e) 

將元素插入佇列，將等待可用的空間（堵塞）

take() 

獲取並移除佇列的頭部，在元素變得可用之前一直等待（堵塞）

public class BlockingQueueTest {
	private static ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(5, true); //最大容量為5的陣列堵塞佇列
	//private static LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>(5);
	
	private static CountDownLatch producerLatch; //倒計時計數器
	private static CountDownLatch consumerLatch;
	
	public static void main(String[] args) {
		BlockingQueueTest queueTest = new BlockingQueueTest();
		queueTest.test();
	}
	
	private void test(){
		producerLatch = new CountDownLatch(10); //state值為10
		consumerLatch = new CountDownLatch(10); //state值為10
		
		Thread t1 = new Thread(new ProducerTask());
		Thread t2 = new Thread(new ConsumerTask());

		//啟動執行緒
		t1.start();
		t2.start();
		
		try {
			System.out.println("producer waiting...");
			producerLatch.await(); //進入等待狀態，直到state值為0，再繼續往下執行
			System.out.println("producer end");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		try {
			System.out.println("consumer waiting...");
			consumerLatch.await(); //進入等待狀態，直到state值為0，再繼續往下執行
			System.out.println("consumer end");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		//結束執行緒
		t1.interrupt(); 
		t2.interrupt();
		
		System.out.println("end");
	}
	
	//生產者
	class ProducerTask implements Runnable{
		private Random rnd = new Random();
		
		@Override
		public void run() {
			try {
				while(true){
					queue.put(rnd.nextInt(100)); //如果queue容量已滿，則當前執行緒會堵塞，直到有空間再繼續
					
					//offer方法為非堵塞的
					//queue.offer(rnd.nextInt(100), 1, TimeUnit.SECONDS); //等待1秒後還不能加入佇列則返回失敗，放棄加入
					//queue.offer(rnd.nextInt(100));
					
					producerLatch.countDown(); //state值減1
					//TimeUnit.SECONDS.sleep(2); //執行緒休眠2秒
				}
			} catch (InterruptedException e) {
				//e.printStackTrace();
			}  catch (Exception ex){
				ex.printStackTrace();
			}
		}
	}
	
	//消費者
	class ConsumerTask implements Runnable{
		@Override
		public void run() {
			try {
				while(true){
					Integer value = queue.take(); //如果queue為空，則當前執行緒會堵塞，直到有新資料加入
					
					//poll方法為非堵塞的
					//Integer value = queue.poll(1, TimeUnit.SECONDS); //等待1秒後還沒有資料可取則返回失敗，放棄獲取
					//Integer value = queue.poll();
					
					System.out.println("value = " + value);
					
					consumerLatch.countDown(); //state值減1
					TimeUnit.SECONDS.sleep(2); //執行緒休眠2秒
				}
			} catch (InterruptedException e) {
				//e.printStackTrace();
			} catch (Exception ex){
				ex.printStackTrace();
			}
		}
	}
	
}