package study;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ProductionAndConsumption {
	
	
	public static int i = 1;
	
	
	
	public static class Work implements Comparable{
		private String workName;
		public Work(String workName) {
			super();
			this.workName = workName;
		}

		public void work(){
			System.out.println("我是工作"+workName+"號");
			System.out.println("我被完成了！！");
		}

		@Override
		public int compareTo(Object o) {
			return 0;
		}
	}
	
	
	public static class WorkConsumption extends Thread{
		
		private BlockingQueue<Work> blockingDeque;

		public WorkConsumption(BlockingQueue<Work> blockingDeque) {
			this.blockingDeque = blockingDeque;
		}

		@Override
		public void run() {
			while (true) {
				try {
					/**
					 * take方法取出BlockingQueue中的工作
					 * 當BlockingQueue空是執行緒阻塞
					 */
					Work work = blockingDeque.take();
					work.work();
					/**
					 * 讓消費者每隔2秒消費一個工作
					 * 控制檯看生產者的工作狀態
					 */
					System.out.println("zzzzzz休息中。。。。。");
					sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	
	public static class WorkProduction extends Thread{
		
		private BlockingQueue<Work> blockingDeque;

		public WorkProduction(BlockingQueue<Work> blockingDeque) {
			this.blockingDeque = blockingDeque;
		}

		@Override
		public void run() {
			while (true) {
				try {
					Work e = new Work(""+i);
					i++;
					/**
					 *向BlockingQueue中放入工作
					 *當BlockingQueue中滿時  執行緒將會阻塞
					 */
					 blockingDeque.put(e);
					 System.out.println("我是生產者，我生產了一個工作"+i);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	
	
	public static void main(String[] args) {
		/**
		 * BlockingQueue 阻塞的佇列
		 * 					資料取出(當執行緒從BlockingQueue中取資料時，如果BlockingQueue中有資料，執行緒將處理BlockingQueue中的資料，
		 * 							如果BlockingQueue中沒有資料的話，執行緒將阻塞，直到BlockingQueue中有資料方能取到)
		 * 					資料放入(當執行緒將資料放入BlockingQueue中時，若BlockingQueue是一個無界佇列，放入資料的執行緒將不會阻塞，
		 * 							如果BlockingQueue是一個有界佇列的話，BlockingQueue滿的時候，放入資料的執行緒將阻塞，直到BlockingQueue中空出位置)
		 * BlockingQueue 的實現佇列 
		 * 				LinkedBlockingQueue： 連結串列形式的阻塞佇列
		 * 				ArrayBlockingQueue：   陣列形式的阻塞佇列
		 * 				PriorityBlockingQueue: 實現優先等級的阻塞佇列(根據優先等級來排序：優先順序高的先執行) 需要實現Comparable介面
		 * 
		 * 
		 * 
		 */
		BlockingQueue<Work> blockingDeque = new ArrayBlockingQueue<Work>(100);
		
		/**
		 * 開始測試
		 */
		
		WorkProduction workProduction = new WorkProduction(blockingDeque);
		workProduction.start();
		
		/**
		 * 主執行緒休息十秒 讓生產者將BlockingQueue填滿，以便消費者工作
		 */
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		/**
		 * 消費者開始工作
		 */
		WorkConsumption worConsumption =  new WorkConsumption(blockingDeque);
		worConsumption.start();
		
	}

}
 

最終執行結果是

<img src="https://img-blog.csdn.net/20141031001137398" alt="" />