1.何为生产者与消费者

    在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * @ClassName:Restraurant
 * @Description:何为生产者与消费者
 * @author: 
 * @date:2018年5月3日
 */
public class Restraurant {
	Meal m=null;
	Chef chef=new Chef(this);
	WaitPerson wait=new WaitPerson(this);
	ExecutorService service=Executors.newCachedThreadPool();
	public Restraurant() {
		service.execute(chef);
		service.execute(wait);
	}
	public static void main(String[] args) {
		new Restraurant();
	}
}
/**
 * @ClassName:Meal
 * @Description:生产者生成的数据
 * @author: 
 * @date:2018年5月3日
 */
class Meal{
	private final int orderNum;//食物订单编号
	public Meal(int num){
		orderNum=num;
	}
	public String toString(){
		return "Meal"+orderNum;
	}
}
/**
 * @ClassName:Chef
 * @Description:厨师类，及生产者
 * @author: 
 * @date:2018年5月3日
 */
class Chef implements Runnable{
	Restraurant r;
	int count=0;
	public Chef(Restraurant r) {
		this.r=r;
	}
	@Override
	public void run() {
		try{
			while(!Thread.interrupted()){
				synchronized (this) {
					while(r.m!=null){
						System.out.println("厨师等待中");
						wait();//等待服务员取餐
					}
				}
				if(count++==10){
					System.out.println("今日已售完");
					r.service.shutdownNow();
				}
				System.out.println("订单完成，服务员取餐");
				synchronized (r.wait) {
					r.m=new Meal(count);
					r.wait.notifyAll();
					
				}
				TimeUnit.SECONDS.sleep(1);
			}
		}catch (InterruptedException e) {
			System.out.println("生产者线程强制中断");
		}
		
	}
}
/**
 * @ClassName:WaitPerson
 * @Description:服务员类，即消费者
 * @author: 
 * @date:2018年5月3日
 */
class WaitPerson implements Runnable{
	Restraurant r;
	public WaitPerson(Restraurant r) {
		this.r=r;
	}
	@Override
	public void run() {
		try {
			while (!Thread.interrupted()) {
				synchronized (this) {
					while (r.m == null) {
						System.out.println("服务员等待中");
						wait();// 等待厨师生成食物
					}
				}

				System.out.println("服务员以取餐" + r.m);
				synchronized (r.chef) {
					r.m = null;
					r.chef.notifyAll();
				}
			}
		} catch (InterruptedException e) {
			System.out.println("消费者线程强制中断");
		}
		
	}
	
}

2.生产者与消费者模式

    1）产生原因：在多线程开发 中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理 完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须 等待生产者。wait与notify方法以一种非常低级的方式解决了任务互相通知的问题，即每次交互都要进行一次握手，极大影响的效率以及性能，为了解决这种生产消费能力不均衡的问题，便有了生产者和消费者模式。

    2）原理：生产者和消费者模式是通过一个容器（比如同步阻塞队列）来解决生产者和消费者的强耦合问题。生产者和消 费者彼此之间不直接通信，而是通过阻塞队列来进行通信，所以生产者生产完数据之后不用 等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取， 阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。 这个阻塞队列就是用来给生产者和消费者解耦的。java.util.concurrent.BlockingQueue接口提供了这个队列，通常使用其实现子类ArrayBlockingQueue，LinkedBlockingQueue。当消费者任务试图从同步队列中获取对象，如果队列为空时，那么队列则会挂起消费者任务，并且当拥有足够多的元素可用时才会恢复消费者任务。

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

public class UseBlockingQueue {
	public static void main(String[] args) throws InterruptedException {
		LinkedBlockingQueue<Toast> dry=new LinkedBlockingQueue<Toast>(),
				butter=new LinkedBlockingQueue<Toast>(),
				jam=new LinkedBlockingQueue<Toast>(),
				con=new LinkedBlockingQueue<Toast>();
		ExecutorService exec=Executors.newCachedThreadPool();
		exec.execute(new MakeToast(dry));//制作初始吐司任务
		exec.execute(new Butter(dry,butter));//吐司抹黄油任务
		exec.execute(new Jam(butter,jam));//吐司抹果酱任务
		exec.execute(new Consumer(jam));//消费者任务，食用吐司
		TimeUnit.SECONDS.sleep(5);
		exec.shutdownNow();
	}
}
class Toast{
	private int status;//吐司状态：0代表制作吐司，1代表抹黄油，2代表向抹了黄油的吐司抹果酱
	private final int id;
	public Toast(int id1) {
		id=id1;
	}
	public void butter(){
		status=1;
	};
	public void jam(){
		status=2;
	}
	public int getStatus(){
		return status;
	}
	public int getId(){
		return id;
	}
	public String toString(){
		return "toast "+id+":"+status;
	}
}
/**
 * @Description:制作初始吐司
 */
class MakeToast implements Runnable{
	private LinkedBlockingQueue<Toast> queue=new LinkedBlockingQueue<Toast>();
	private int count=0;
	public MakeToast(LinkedBlockingQueue<Toast> q) {
		queue=q;
	}
	@Override
	public void run() {
		try{
			while(!Thread.interrupted()){
				Thread.sleep(1000);//制作时间
				Toast t=new Toast(count);
				System.out.println(t);
				queue.put(t);//添加到同步队列
				count++;
			}
		}catch (InterruptedException e) {
			System.out.println("make process interrupted");
		}
		System.out.println("make process off");
	}
}
/**
 * @Description:涂抹黄油
 */
class Butter implements Runnable{
	private LinkedBlockingQueue<Toast> queue1,queue2;//未加料吐司队列，抹黄油后吐司队列
	public Butter(LinkedBlockingQueue<Toast> q1,LinkedBlockingQueue<Toast>q2) {
		queue1=q1;
		queue2=q2;
	}
	@Override
	public void run() {
		try{
			while(!Thread.interrupted()){
				Toast t=queue1.take();//如果队列中没有可用元素将会阻塞，直至有可用元素被添加
				t.butter();
				System.out.println(t);
				queue2.put(t);
			}
		}catch (InterruptedException e) {
			System.out.println("butter process interrupted");
		}
		System.out.println("butter process off");
	}
}
/**
 * @Description:涂抹果酱
 */
class Jam implements Runnable{
	private LinkedBlockingQueue<Toast> queue1,queue2;//抹黄油后吐司队列,抹果酱吐司队列
	public Jam(LinkedBlockingQueue<Toast> q1,LinkedBlockingQueue<Toast>q2) {
		queue1=q1;
		queue2=q2;
	}
	@Override
	public void run() {
		try{
			while(!Thread.interrupted()){
				Toast t=queue1.take();//如果队列中没有可用元素将会阻塞，直至有可用元素被添加
				t.jam();
				System.out.println(t);
				queue2.put(t);
			}
		}catch (InterruptedException e) {
			System.out.println("jam process interrupted");
		}
		System.out.println("jam process off");
	}
}
/**
 * @Description:被食用
 */
class Consumer implements Runnable{
	private LinkedBlockingQueue<Toast> finished;//抹黄油后吐司队列,抹果酱吐司队列
	int count=0;
	public Consumer(LinkedBlockingQueue<Toast> q) {
		finished=q;
	}
	@Override
	public void run() {
		try{
			while(!Thread.interrupted()){
				Toast t=finished.take();//如果队列中没有可用元素将会阻塞，直至有可用元素被添加
				if(t.getId()!=count++||t.getStatus()!=2){
					System.out.println("过程出现错误");
					return;
				}else{
					System.out.println("所有过程正确实现"+"toast "+t.getId()+"被食用");
				}
			}
		}catch (InterruptedException e) {
			System.out.println("eat process interrupted");
		}
		System.out.println("eat process off");
	}
}