Java執行緒(篇外篇)：阻塞佇列BlockingQueue

 好久沒有寫文章了，這段時間事情比較雜，工作也比較雜亂，上週日剛搬完家，從自建房搬到了樓房，提升了一層生活品質，哈哈！不過昨天晚上在公交車上錢包被偷了，前段時間還丟個自行車，不得不感嘆，京城扒手真多，還無人處理。言歸正傳，這一段時間我的工作主要是改進公司的排程器，排程器排程執行緒池執行任務，生產者生產任務，消費者消費任務，那麼這時就需要一個任務佇列，生產者向佇列裡插入任務，消費者從佇列裡提取任務執行，排程器裡是通過BlockingQueue實現的佇列，隨後小查一下，下面看看BlockingQueue的原理及其方法。

       BlockingQueue最終會有四種狀況，丟擲異常、返回特殊值、阻塞、超時，下表總結了這些方法：

	丟擲異常	特殊值	阻塞	超時
插入	add(e)	offer(e)	put(e)	offer(e, time, unit)
移除	remove()	poll()	take()	poll(time, unit)
檢查	element()	peek()	不可用	不可用

       BlockingQueue是個介面，有如下實現類：

       1. ArrayBlockQueue：一個由陣列支援的有界阻塞佇列。此佇列按 FIFO（先進先出）原則對元素進行排序。建立其物件必須明確大小，像陣列一樣。

       2. LinkedBlockQueue：一個可改變大小的阻塞佇列。此佇列按 FIFO（先進先出）原則對元素進行排序。建立其物件如果沒有明確大小，預設值是Integer.MAX_VALUE。連結佇列的吞吐量通常要高於基於陣列的佇列，但是在大多數併發應用程式中，其可預知的效能要低。 

       3. PriorityBlockingQueue：類似於LinkedBlockingQueue，但其所含物件的排序不是FIFO，而是依據物件的自然排序順序或者是建構函式所帶的Comparator決定的順序。

       4. SynchronousQueue：同步佇列。同步佇列沒有任何容量，每個插入必須等待另一個執行緒移除，反之亦然。

       下面使用ArrayBlockQueue來實現之前實現過的生產者消/費者模式，程式碼如下：

/** 定義一個盤子類，可以放雞蛋和取雞蛋 */
public class BigPlate {

	/** 裝雞蛋的盤子，大小為5 */
	private BlockingQueue<Object> eggs = new ArrayBlockingQueue<Object>(5);
	
	/** 放雞蛋 */
	public void putEgg(Object egg) {
		try {
			eggs.put(egg);// 向盤子末尾放一個雞蛋，如果盤子滿了，當前執行緒阻塞
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		// 下面輸出有時不準確，因為與put操作不是一個原子操作
		System.out.println("放入雞蛋");
	}
	
	/** 取雞蛋 */
	public Object getEgg() {
		Object egg = null;
		try {
			egg = eggs.take();// 從盤子開始取一個雞蛋，如果盤子空了，當前執行緒阻塞
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		// 下面輸出有時不準確，因為與take操作不是一個原子操作
		System.out.println("拿到雞蛋");
		return egg;
	}
	
	/** 放雞蛋執行緒 */
	static class AddThread extends Thread {
		private BigPlate plate;
		private Object egg = new Object();

		public AddThread(BigPlate plate) {
			this.plate = plate;
		}

		public void run() {
			plate.putEgg(egg);
		}
	}

	/** 取雞蛋執行緒 */
	static class GetThread extends Thread {
		private BigPlate plate;

		public GetThread(BigPlate plate) {
			this.plate = plate;
		}

		public void run() {
			plate.getEgg();
		}
	}
	
	public static void main(String[] args) {
		BigPlate plate = new BigPlate();
		// 先啟動10個放雞蛋執行緒
		for(int i = 0; i < 10; i++) {
			new Thread(new AddThread(plate)).start();
		}
		// 再啟動10個取雞蛋執行緒
		for(int i = 0; i < 10; i++) {
			new Thread(new GetThread(plate)).start();
		}
	}
}

執行結果：

放入雞蛋
放入雞蛋
放入雞蛋
放入雞蛋
放入雞蛋
拿到雞蛋
放入雞蛋
拿到雞蛋
拿到雞蛋
拿到雞蛋
放入雞蛋
放入雞蛋
放入雞蛋
拿到雞蛋
放入雞蛋
拿到雞蛋
拿到雞蛋
拿到雞蛋
拿到雞蛋
拿到雞蛋

從結果看，啟動10個放雞蛋執行緒和10個取雞蛋執行緒，前5個放入雞蛋的執行緒成功執行，到第6個，發現盤子滿了，阻塞住，這時切換到取雞蛋執行緒執行，成功實現了生產者/消費者模式。java.util.concurrent包是個強大的包！

        本文來自：高爽|Coder，原文地址：http://blog.csdn.net/ghsau/article/details/8108292。