生产者与消费者模型案例

/*@author shijin
* 生产者与消费者模型中，要保证以下几点：
* 1 同一时间内只能有一个生产者生产		生产方法加锁sychronized
* 2 同一时间内只能有一个消费者消费		消费方法加锁sychronized
* 3 生产者生产的同时消费者不能消费		生产方法加锁sychronized
* 4 消费者消费的同时生产者不能生产		消费方法加锁sychronized
* 5 共享空间空时消费者不能继续消费		消费前循环判断是否为空，空的话将该线程wait，释放锁允许其他同步方法执行
* 6 共享空间满时生产者不能继续生产		生产前循环判断是否为满，满的话将该线程wait，释放锁允许其他同步方法执行   
*/

//主类
class  ProducerConsumer
{
	public static void main(String[] args) 
	{
		StackBasket s = new StackBasket();
		Producer p = new Producer(s);
		Consumer c = new Consumer(s);
		Thread tp = new Thread(p);
		Thread tc = new Thread(c);
		tp.start();
		tc.start();
	}
}

//
class Mantou
{
	private int id;
	
	Mantou(int id){
		this.id = id;
	}

	public String toString(){
		return "Mantou :" + id;
	}
}

//共享栈空间
class StackBasket
{
	Mantou sm[] = new Mantou[6];
	int index = 0;
	
	/** 
	* show 生产方法.
	* show 该方法为同步方法，持有方法锁；
	* show 首先循环判断满否，满的话使该线程等待，释放同步方法锁，允许消费；
	* show 当不满时首先唤醒正在等待的消费方法，但是也只能让其进入就绪状态，
	* show 等生产结束释放同步方法锁后消费才能持有该锁进行消费
	* @param m 元素
	* @return 没有返回值 
	*/ 

	public synchronized void push(Mantou m){
		try{
			while(index == sm.length){
				System.out.println("!!!!!!!!!生产满了!!!!!!!!!");
				this.wait();
			}
			this.notify();
		}catch(InterruptedException e){
			e.printStackTrace();
		}catch(IllegalMonitorStateException e){
			e.printStackTrace();
		}
		
		sm[index] = m;
		index++;
		System.out.println("生产了：" + m + " 共" + index + "个馒头");
	}

	/** 
	* show 消费方法
	* show 该方法为同步方法，持有方法锁
	* show 首先循环判断空否，空的话使该线程等待，释放同步方法锁，允许生产；
	* show 当不空时首先唤醒正在等待的生产方法，但是也只能让其进入就绪状态
	* show 等消费结束释放同步方法锁后生产才能持有该锁进行生产
	* @param b true 表示显示，false 表示隐藏 
	* @return 没有返回值 
	*/ 
	public synchronized Mantou pop(){
		try{
			while(index == 0){
				System.out.println("!!!!!!!!!消费光了!!!!!!!!!");
				this.wait();
			}
			this.notify();
		}catch(InterruptedException e){
			e.printStackTrace();
		}catch(IllegalMonitorStateException e){
			e.printStackTrace();
		}
		index--;
		System.out.println("消费了：---------" + sm[index] + " 共" + index + "个馒头");
		return sm[index];
	}
}

class Producer implements Runnable
{
	StackBasket ss = new StackBasket();
	Producer(StackBasket ss){
		this.ss = ss;
	}

	/** 
	* show 生产进程. 
	*/ 
	public void run(){
		for(int i = 0;i < 20;i++){
			Mantou m = new Mantou(i);
			ss.push(m);
//			System.out.println("生产了：" + m + " 共" + ss.index + "个馒头");
//			在上面一行进行测试是不妥的，对index的访问应该在原子操作里，因为可能在push之后此输出之前又消费了，会产生输出混乱
			try{
				Thread.sleep((int)(Math.random()*500));
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
	}
}

class Consumer implements Runnable
{
	StackBasket ss = new StackBasket();
	Consumer(StackBasket ss){
		this.ss = ss;
	}

	/** 
	* show 消费进程.
	*/ 
	public void run(){
		for(int i = 0;i < 20;i++){
			Mantou m = ss.pop();
//			System.out.println("消费了：---------" + m + " 共" + ss.index + "个馒头");
//	同上	在上面一行进行测试也是不妥的，对index的访问应该在原子操作里，因为可能在pop之后此输出之前又生产了，会产生输出混乱
			try{
				Thread.sleep((int)(Math.random()*1000));
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
	}
}