執行緒的通訊
前面學習了用wait/notify的方式進行執行緒通訊。今天學習一種更加強大的執行緒通訊方式Condition.Condition的強大之處就是可以為執行緒建立不同的Condition。然後可以喚醒任意指定阻塞的執行緒。Condition之所以能為一個執行緒建立不同的Condition，是因為它也維護著一個阻塞的條件佇列。它跟AQS等待佇列通過執行緒的等待、喚醒建立關係。
1.每當AQS佇列中的執行緒呼叫Condition.await()方法，AQS就會把當前執行緒從佇列中移除，並加入到Condition佇列的尾部並阻塞，然後等待喚醒。
2.每當AQS佇列中執行緒對Condition佇列中的某個阻塞執行緒進行了Condition.sinal()方法，Condition佇列就會把該執行緒從佇列中移除，執行緒加入AQS等待佇列末尾，等待獲取鎖。
通過Condition實現多執行緒的消費者、生產者模式來進一步理解：

public class ConditionTest {


    static class Depot{

        private int size;
        private ReentrantLock  lock = null;
        private  Condition  notEmptyCondition = null ;
        private  Condition  notFullCondition = null;
        private  List<Integer> depots;


        public
 
 Depot(int size) {
            this.size = size;
            lock = new ReentrantLock();
            notEmptyCondition = lock.newCondition();
            notFullCondition = lock.newCondition();
            depots = new LinkedList<Integer>();
        }


        /**
         * 每次生產count個產品
         * @param count
         */
 

        public void producer(int count) {
            lock.lock();
            try {
                while(depots.size()  > 0){
                    System.out.println("倉庫已經有鏟產品了，可以開始消費了");
                    notFullCondition.await();  //倉庫滿了進行等待消費
                }
            int actCount = (count + depots.size()) > size ? (size - depots.size()) : count; //如果生產的數量和現有的數量大於總數，就只生產倉庫剩餘的最大容量數
           System.out.println(Thread.currentThread().getName() + "執行緒開始生產");
            for(int i = 0; i < actCount; i++ ) {
                depots.add(i);
             }
            System.out.println(Thread.currentThread().getName() + "生產完畢，當前倉庫有" + depots.size() + "個產品");
             notEmptyCondition.signal();
            } catch (InterruptedException e) {
                 e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }



        public void consumer(int count) {
            lock.lock();
            try {
                while(depots.size() == 0) {
                    System.out.println("當前倉庫為空，等待生產");
                    notEmptyCondition.await();
                }
                int actCount = (depots.size() > count ) ? count : depots.size();//如果當前倉庫剩餘容量大於消費容量，就消費消費個，如果消費的容量比倉庫剩餘容量大，就把剩餘的都消費掉。
                  System.out.println(Thread.currentThread().getName() + "執行緒開始消費");
                Iterator<Integer> iterator = depots.iterator();
                while(iterator.hasNext() && actCount > 0  ) {
                    iterator.next();
                    iterator.remove();
                    actCount--;
                }
                System.out.println(Thread.currentThread().getName() + "消費完畢，當前倉庫有" + depots.size() + "個產品");
                notFullCondition.signal();

            } catch (Exception e) {
                e.printStackTrace();
            }finally {

                lock.unlock();
            }


        }

    }

    public static void main(String[] args) {
        final Depot depot = new Depot(100);

        for(int i = 0; i < 30; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        depot.producer(40);
                    }
                }
            },"producer-" + i );
            thread.start();
        }


        for(int i = 0; i < 30; i++) {
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        depot.consumer(80);
                    }
                }
            },"consumer-" + i);
            thread1.start();
        }

    }

}

某一次執行部分結果

producer-20執行緒開始生產
producer-20生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-2執行緒開始消費
cusume-2消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-21執行緒開始生產
producer-21生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-28執行緒開始消費
cusume-28消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-15執行緒開始生產
producer-15生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-11執行緒開始消費
cusume-11消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-24執行緒開始生產
producer-24生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-14執行緒開始消費
cusume-14消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-19執行緒開始生產
producer-19生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-4執行緒開始消費
cusume-4消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-25執行緒開始生產
producer-25生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-15執行緒開始消費
cusume-15消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-8執行緒開始生產
producer-8生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-20執行緒開始消費
cusume-20消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-29執行緒開始生產
producer-29生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-5執行緒開始消費
cusume-5消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-1執行緒開始生產
producer-1生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-0執行緒開始消費
cusume-0消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-26執行緒開始生產
producer-26生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-18執行緒開始消費
cusume-18消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-16執行緒開始生產
producer-16生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-19執行緒開始消費
cusume-19消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-3執行緒開始生產
producer-3生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-12執行緒開始消費
cusume-12消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-7執行緒開始生產
producer-7生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-22執行緒開始消費
cusume-22消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-11執行緒開始生產
producer-11生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-26執行緒開始消費
cusume-26消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-2執行緒開始生產
producer-2生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-1執行緒開始消費
cusume-1消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-28執行緒開始生產
producer-28生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-23執行緒開始消費
cusume-23消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產
producer-10執行緒開始生產
producer-10生產完畢，當前倉庫有40個產品
倉庫已經有鏟產品了，可以開始消費了
cusume-27執行緒開始消費
cusume-27消費完畢，當前倉庫有0個產品
當前倉庫為空，等待生產

上面是簡單模擬生產者消費者的例子。當然其中還有很多變化。還有就是用List來做儲存。這個在多執行緒高併發環境下是不安全的等等。以後會學習JUC下的集合以及一些併發類。就能寫出越來越安全的生產者消費真模式。