BlockingQueue作為執行緒容器，可以為執行緒同步提供有力的保障，其主要用到的方法包括：

add(E o); //將指定的元素新增到此佇列中（如果立即可行），在成功時返回 true，其他情況則丟擲 IllegalStateException。
drainTo(Collection<? super E> c);  //移除此佇列中所有可用的元素，並將它們新增到給定 collection 中。
drainTo(Collection<? super E> c,int maxElements);//最多從此佇列中移除給定數量的可用元素，並將這些元素新增到給定 collection 中
offer(E o);  //如果可能的話，將指定元素插入此佇列中。
offer(E o, long timeout, TimeUnit unit);  //將指定的元素插入此佇列中，如果沒有可用空間，將等待指定的等待時間（如果有必要）。
poll(long timeout, TimeUnit unit);  //檢索並移除此佇列的頭部，如果此佇列中沒有任何元素，則等待指定等待的時間（如果有必要）。
put(E o);    //將指定元素新增到此佇列中，如果沒有可用空間，將一直等待（如果有必要）。
remainingCapacity();  //返回在無阻塞的理想情況下（不存在記憶體或資源約束）此佇列能接受的元素數量；如果沒有內部限制，則返回 Integer.MAX_VALUE。
take();  //檢索並移除此佇列的頭部，如果此佇列不存在任何元素，則一直等待。
 

       BlockingQueue 可以定義為限定容量的佇列，它有一個 remainingCapacity容量值，超出此容量，便無法無阻塞地 put 額外的元素。也可以定義為沒有容量限制的佇列，沒有容量約束的 BlockingQueue 總是報告 Integer.MAX_VALUE 的剩餘容量。

       BlockingQueue 實現是執行緒安全的。所有排隊方法都可以使用內部鎖定或其他形式的併發控制來自動達到它們的目的。然而，大量的 Collection 操作（addAll、containsAll、retainAll 和 removeAll）沒有 必要自動執行，除非在實現中特別說明。因此，舉例來說，在只添加了 c 中的一些元素後，addAll(c) 有可能失敗（丟擲一個異常）。它實質上不 支援使用任何一種“close”或“shutdown”操作來指示不再新增任何項。這種功能的需求和使用有依賴於實現的傾向。例如，一種常用的策略是：對於生產者，插入特殊的 end-of-stream 或 poison 物件，並根據使用者獲取這些物件的時間來對它們進行解釋。

      BlockingQueue 主要用於實現生產者-使用者佇列，但它另外還支援 Collection 介面。因此，舉例來說，使用 remove(x) 從佇列中移除任意一個元素是有可能的。然而，這種操作通常不 會有效執行，只能有計劃地偶爾使用，比如在取消排隊資訊時。阻塞佇列與Semaphore有很大相似性，但也有很多不同，阻塞佇列一般是一方存資料，另一方釋放資料，而Semaphore通常是同一方獲取和釋放訊號。下面通過一個例子加以說明：

public class BlockingQueueTest {
	public static void main(String[] args) {
		final BlockingQueue queue = new ArrayBlockingQueue(3);
		for(int i=0;i<2;i++){
			new Thread(){
				public void run(){
					while(true){
						try {
						Thread.sleep((long)(Math.random()*1000));
						System.out.println(Thread.currentThread().getName() + "準備放資料!");							
							queue.put(1);
System.out.println(Thread.currentThread().getName() + "已經放了資料，" + 	"佇列目前有" + queue.size() + "個數據");
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}
				
			}.start();
		}
		new Thread(){
			public void run(){
				while(true){
					try {
					//將此處的睡眠時間分別改為100和1000，觀察執行結果
					Thread.sleep(1000);
					System.out.println(Thread.currentThread().getName() + "準備取資料!");
					queue.take();
					System.out.println(Thread.currentThread().getName() + "已經取走資料，" + 
								"佇列目前有" + queue.size() + "個數據");		
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}.start();			
	}
}

Thread-1準備放資料!
Thread-1已經放了資料，佇列目前有1個數據
Thread-1準備放資料!
Thread-1已經放了資料，佇列目前有2個數據
Thread-0準備放資料!
Thread-0已經放了資料，佇列目前有3個數據
Thread-0準備放資料!
Thread-2準備取資料!
Thread-2已經取走資料，佇列目前有2個數據

BlockingQueue<Integer> queue1 = new ArrayBlockingQueue<Integer>(1);
 BlockingQueue<Integer> queue2 = new ArrayBlockingQueue<Integer>(1);
 public  void sub(int i){
			  	try {
					queue1.put(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				for(int j=1;j<=10;j++){
					System.out.println("sub thread sequece of " + j + ",loop of " + i);
				}
				try {
					queue2.take();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		  }
		  public  void main(int i){
			  	try {
					queue2.put(1);
				} catch (InterruptedException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				for(int j=1;j<=100;j++){
					System.out.println("main thread sequece of " + j + ",loop of " + i);
				}
				try {
					queue1.take();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		  }