BlockingQueue实现生产者消费者模式

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。
这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。
阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。
阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。使用阻塞队列可以忽略同步问题，因为它们已经有BlockingQueue解决了。

package com.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class Product{
	private int id;
	public Product(int id){
		this.id=id;
	}
	
	public String toString(){
		return "product "+id;
	}
}

class Producter implements Runnable{
	private BlockingQueue<Product> queue;
	private int count=0;
	
	public Producter(BlockingQueue<Product> queue){
		this.queue=queue;
	}
	
	public void run(){
		try{
			while(!Thread.interrupted()){
				TimeUnit.MILLISECONDS.sleep(100);
				Product product=new Product(count++);
				System.out.println("Producter produce "+product);
				queue.put(product);
			}
		}catch(InterruptedException e){
			System.out.println("Producter interrupted");
		}
	}
}

class Consumer implements Runnable{
	private BlockingQueue<Product> queue;
	
	public Consumer(BlockingQueue<Product> queue){
		this.queue=queue;
	}
	
	public void run(){
		try{
			while(!Thread.interrupted()){
				TimeUnit.MICROSECONDS.sleep(100);
				Product product=queue.take();
				System.out.println("Consumer get "+product);
			}
		}catch(InterruptedException e){
			System.out.println("Consumer interrupter");
		}
	}
}

public class ProducterAndConsumer {
	public static void main(String[] args) throws InterruptedException{
		ExecutorService exec=Executors.newCachedThreadPool();
		BlockingQueue<Product> queue=new ArrayBlockingQueue<Product>(10);
		exec.execute(new Producter(queue));
		exec.execute(new Consumer(queue));
		
		TimeUnit.SECONDS.sleep(1);
		exec.shutdownNow();
	}
}