多线程解决生产者与消费者问题

       生产者消费者问题是一个很有名的线程同步问题，以前学操作系统时，没怎么搞懂，直到现在学java学到多线程这一块才搞懂。该问题描述的是两个共享固定大小的缓冲区的线程问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据.

       要解决该问题，就必须让生产者在缓冲区满时休眠（为了简单起见，本例就一个生产者与一个消费者），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。

       下面我用java实现一下：

        本例的生产者是厨师，消费者是服务员

生产者（厨师）只负责生产（做菜），在线程里面用一个循环，使厨师不停的做菜

package producer_and_customer;
/**
 * 生产者:厨师做菜
 * @author weixian
 */
public class Product implements Runnable {
	private Food food;
	
	public Product(Food food){
		this.food=food;
	}
	@Override
	public void run() {
		for(int i=0;i<50;i++){
			if(i%2==0){
				food.setFood("辣椒炒肉","很辣很好吃！");
			}else{
				food.setFood("鸡蛋干炒肉","有点臭，不好吃！");
			}
		}
	}
}
           

这里我使用一个循环使厨师不停的生产两道菜，由于启用的是线程，没有设置优先级，所有菜名和菜的描述在输出时可能会不对应，所有这里我使用同步方法实现，代码在后面贴出。

消费者（服务员）只负责消费（上菜），在线程里面也用一个循环，使服务员不停的做菜

package producer_and_customer;
/**
 * 消费者：服务员上菜
 * @author weixian
 */
public class Customer implements Runnable{
	private Food food;
	
	public Customer(Food food){
		this.food=food;
	}
	@Override
	public void run() {
		for(int j=0;j<50;j++){
			food.getFood();
		}
	}
}
           

这里同生产者厨师一样，输出也有可能不对应，所以也必须使用同步方法，同步方法写在Food类中

package producer_and_customer;
public class Food {
	private String name;
	private String des;
	private boolean flag = true; //true 代表可以生产  false代表可以消费

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public synchronized void setFood(String name,String des){
		if(!flag){
			try {
				this.wait();  //进入等待状态，不能生产
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.setName(name);
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.setDes(des);
		flag = false;  //表示可以消费了
		this.notify(); //唤醒当前线程
	}
	
	public String getDes() {
		return des;
	}
	
	public synchronized void getFood(){
		if(flag){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(this.getName()+":"+this.getDes());
		flag = true; //表示可以生产了
		this.notify(); //唤醒当前线程
	}
	
	public void setDes(String des) {
		this.des = des;
	}
	@Override
	public String toString() {
		return "Food [name=" + name + ", des=" + des + "]";
	}
	public Food(String name, String des) {
		super();
		this.name = name;
		this.des = des;
	}
	public Food() {
		super();
	}
}
           

在Food类中不仅有两个同步方法分别对应生产者与消费者，在其中还定义了一个变量flag，通过这个flag来控制生产者的生产与消费者的消费。因为这两个操作不能同时进行，所以在生产者（厨师）在生产（做菜）的时候，消费者（服务员）不能消费（上菜）。服务员应该等待厨师把才做好，才能上菜。此时服务员等待，等到厨师做好后唤醒服务员上菜，反之亦然。道理就只有一个，两个操作不能同时进行。

这个问题的核心就是要解决两个问题：

1、菜名与菜的描述一定要对应。所以要使用同步

2、厨师与服务员的操作不能同时进行。所以要用flag控制线程的等待与唤醒

通过在主类中启动线程运行

Food food = new Food();
Product product = new Product( food );
Customer customer = new Customer(food);
new Thread(product).start();
new Thread(customer).start();
           

运行结果如下：