import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
/**
    本例介紹一個特殊的隊列:BlockingQueue,如果BlockQueue是空的,從BlockingQueue取東西的操作將會被阻斷進入等待狀態(tài),直到BlockingQueue進了東西才會被喚醒.同樣,如果BlockingQueue是滿的,任何試圖往里存東西的操作也會被阻斷進入等待狀態(tài),直到BlockingQueue里有空間才會被喚醒繼續(xù)操作.
    本例再次實現(xiàn)11.4線程----條件Condition中介紹的籃子程序,不過這個籃子中最多能放的蘋果數(shù)不是1,可以隨意指定.當籃子滿時,生產(chǎn)者進入等待狀態(tài),當籃子空時,消費者等待.
 */
/**
    使用BlockingQueue的關鍵技術點如下:
    1.BlockingQueue定義的常用方法如下:
        1)add(anObject):把anObject加到BlockingQueue里,即如果BlockingQueue可以容納,則返回true,否則招聘異常
        2)offer(anObject):表示如果可能的話,將anObject加到BlockingQueue里,即如果BlockingQueue可以容納,則返回true,否則返回false.
        3)put(anObject):把anObject加到BlockingQueue里,如果BlockQueue沒有空間,則調用此方法的線程被阻斷直到BlockingQueue里面有空間再繼續(xù).
        4)poll(time):取走BlockingQueue里排在首位的對象,若不能立即取出,則可以等time參數(shù)規(guī)定的時間,取不到時返回null
        5)take():取走BlockingQueue里排在首位的對象,若BlockingQueue為空,阻斷進入等待狀態(tài)直到Blocking有新的對象被加入為止
    2.BlockingQueue有四個具體的實現(xiàn)類,根據(jù)不同需求,選擇不同的實現(xiàn)類
        1)ArrayBlockingQueue:規(guī)定大小的BlockingQueue,其構造函數(shù)必須帶一個int參數(shù)來指明其大小.其所含的對象是以FIFO(先入先出)順序排序的.
        2)LinkedBlockingQueue:大小不定的BlockingQueue,若其構造函數(shù)帶一個規(guī)定大小的參數(shù),生成的BlockingQueue有大小限制,若不帶大小參數(shù),所生成的BlockingQueue的大小由Integer.MAX_VALUE來決定.其所含的對象是以FIFO(先入先出)順序排序的
        3)PriorityBlockingQueue:類似于LinkedBlockQueue,但其所含對象的排序不是FIFO,而是依據(jù)對象的自然排序順序或者是構造函數(shù)的Comparator決定的順序.
        4)SynchronousQueue:特殊的BlockingQueue,對其的操作必須是放和取交替完成的.
    3.LinkedBlockingQueue和ArrayBlockingQueue比較起來,它們背后所用的數(shù)據(jù)結構不一樣,導致LinkedBlockingQueue的數(shù)據(jù)吞吐量要大于ArrayBlockingQueue,但在線程數(shù)量很大時其性能的可預見性低于ArrayBlockingQueue.         
 */
public class BlockingQueueTest {
       /**定義裝蘋果的籃子*/
       public static class Basket{
              //籃子,能夠容納3個蘋果
              BlockingQueue<String> basket = new ArrayBlockingQueue<String>(3);
              //生產(chǎn)蘋果,放入籃子
              public void produce() throws InterruptedException{
                     //put方法放入一個蘋果,若basket滿了,等到basket有位置
                     basket.put("An apple");
              }
              //消費蘋果,從籃子中取走
              public String consume() throws InterruptedException{
                     //take方法取出一個蘋果,若basket為空,等到basket有蘋果為止
                     return basket.take();
              }
       }
       //測試方法
       public static void testBasket(){
              final Basket basket = new Basket();//建立一個裝蘋果的籃子
              //定義蘋果生產(chǎn)者
              class Producer implements Runnable{
                     public void run(){
                            try{
                                   while(true){
                                          //生產(chǎn)蘋果
                                          System.out.println("生產(chǎn)者準備生產(chǎn)蘋果: " + System.currentTimeMillis());
                                          basket.produce();
                                          System.out.println("生產(chǎn)者生產(chǎn)蘋果完畢: " + System.currentTimeMillis());
                                          //休眠300ms
                                          Thread.sleep(300);
                                   }
                            }catch(InterruptedException ex){
                            }
                     }
              }
              //定義蘋果消費者
              class Consumer implements Runnable{
                     public void run(){
                            try{
                                   while(true){
                                          //消費蘋果
                                          System.out.println("消費者準備消費蘋果: " + System.currentTimeMillis());
                                          basket.consume();
                                          System.out.println("消費者消費蘋果完畢: " + System.currentTimeMillis());
                                          //休眠1000ms
                                          Thread.sleep(1000);
                                   }
                            }catch(InterruptedException ex){
                            }
                     }
              }
              ExecutorService service = Executors.newCachedThreadPool();
              Producer producer = new Producer();
              Consumer consumer = new Consumer();
              service.submit(producer);
              service.submit(consumer);
              //程序運行5s后,所有任務停止
              try{
                     Thread.sleep(5000);
              }catch(InterruptedException ex){
              }
              service.shutdownNow();
       }
       public static void main(String[] args){
              BlockingQueueTest.testBasket();
       }
}