在java多執行緒操作中， BlockingQueue<E> 常用的一種方法之一。在看jdk內部尤其是一些多執行緒，大量使用了blockinkQueue 來做的。 

借用jdk api解釋下：

BlockingQueue 方法以四種形式出現，對於不能立即滿足但可能在將來某一時刻可以滿足的操作，這四種形式的處理方式不同：第一種是丟擲一個異常，第二種是返回一個特殊值（null 或 false，具體取決於操作），第三種是在操作可以成功前，無限期地阻塞當前執行緒，第四種是在放棄前只在給定的最大時間限制內阻塞。下表中總結了這些方法：

offer: 將指定元素插入此佇列中（如果立即可行且不會違反容量限制），成功時返回 true

java原始碼

 public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
                return false;
            else {
                insert(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }
 

將指定元素插入此佇列中，將等待可用的空間.通俗點說就是>maxSize 時候，阻塞，直到能夠有空間插入元素

java原始碼：

 public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        final E[] items = this.items;
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            try {
                while (count == items.length)
                    notFull.await();
            } catch (InterruptedException ie) {
                notFull.signal(); // propagate to non-interrupted thread
                throw ie;
            }
            insert(e);
        } finally {
            lock.unlock();
        }
    }
 

take: 獲取並移除此佇列的頭部，在元素變得可用之前一直等待 。queue的長度 == 0 的時候，一直阻塞

java 原始碼：

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            try {
                while (count == 0)
                    notEmpty.await();
            } catch (InterruptedException ie) {
                notEmpty.signal(); // propagate to non-interrupted thread
                throw ie;
            }
            E x = extract();
            return x;
        } finally {
            lock.unlock();
        }
    }

例子如下：

	public static void main(String[] args) {
		java.util.concurrent.Executor executor = Executors.newFixedThreadPool(10);
		Runnable task = new Runnable() {
			
			@Override
			public void run() {
				System.out.println("ggg");
			}
		};
		executor.execute(task);
		*/
		
		 BlockingQueue q = new ArrayBlockingQueue(10);
	     Producer p = new Producer(q);
	     Consumer c1 = new Consumer(q);
	     Consumer c2 = new Consumer(q);
	     new Thread(p).start();
	     new Thread(c1).start();
	     new Thread(c2).start();

	}
}


class Producer implements Runnable {
	   private final BlockingQueue<Object> queue;
	   Producer(BlockingQueue q) { queue = q; }
	   public void run() {
	     for(int i=0;i<100;i++){
	    	 try {
				queue.put(i);
			} catch (InterruptedException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			} 
	    	 try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	     }
	   }

	 }

	 class Consumer implements Runnable {
	   private final BlockingQueue queue;
	   Consumer(BlockingQueue q) { queue = q; }
	   public void run() {
	     try {
	       while(true) { 
	    	   consume(
	    			   queue.take()
	    			   ); 
	    	   }
	     } catch (InterruptedException ex) {
	    	 
	     }
	   }
	   void consume(Object x) {
		   System.out.println(x);
		   
	   }
	 }