producerconsumer.java

生产者与消费者线程同步问题的一个模拟

public class ProducerConsumer{
	public static void main(String[] args){
		SyncStack ss=new SyncStack(3);//创建容量为 3 的一个放馒头的容器，就是一个栈，容量为3 
		Producer p=new Producer(ss);//创建生产者对象
		Consumer c=new Consumer(ss);//创建消费者对象
		new Thread(p,"p1").start();//创建生产者一个线程
		new Thread(p,"p2").start();//再创建生产者线程
		new Thread(c,"c1").start();//创建消费者线程
		new Thread(c,"c2").start();//创建消费者线程
	}
}
class ManTou{//馒头类的定义
	int id=0;//每创建一个馒头，给它一个编号
	public ManTou(int id){//构造方法
		this.id=id;
	}
	public String toString(){//重写父类的toString()方法，以便输出自定义的对象格式
		return "ManTou:"+id;
	}
}
class SyncStack{//定义放馒头的容器，即定义一个栈
	private int index=0;//记录数组下标
	private int content;//定义栈的容量
	private ManTou[] mt;//用一个馒头数组进行存放
	public SyncStack(int content){//构造方法，设置栈容量并初始化数组
		this.content=content;
		mt=new ManTou[this.content];
	}
	public synchronized void pop(){//吃一个馒头的方法，要进行 防死锁处理
		while(index==0){//判断栈是不是为空
			try{
				this.wait();//若栈为空，就让当前线程 消费者线程 等待
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		this.notifyAll();//唤醒生产者线程			
			index--;
			System.out.println("线程"+Thread.currentThread().getName()+"消费了"+mt[index]);
			mt[index]=null;	
	}
	public synchronized void push(ManTou oneMT){//生产一个馒头，放进栈里，进行防死锁处理
		while(index==content){//判断栈满
			try{
				this.wait();//若栈满就等待
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		this.notifyAll();//唤醒消费者线程
		mt[index]=oneMT;
		System.out.println("线程"+Thread.currentThread().getName()+"生产了"+mt[index]);
		index++;
	}	 
}
class Producer implements Runnable{//定义消费者类，因为要用线程，所以实现Runnable接口
	SyncStack ss=null;//存放要对哪个容器操作，即栈，应该与消费者操作的栈是同一个
	private int num=0;//记录当前馒头的编号
	public Producer(SyncStack ss){
		this.ss=ss;
	}
	public void run(){
		for(int i=0;i<5;i++){
			ManTou mt=new ManTou(num++);
			ss.push(mt);
			try{
				Thread.sleep(1000);//为了调试用 ，当前线程休眠 1 秒
			}catch(InterruptedException e){
					e.printStackTrace();		
				}
		}
	}
}
class Consumer implements Runnable{//定义消费者类，因为要用线程，所以实现Runnable接口
	SyncStack ss=null;//存放要对哪个容器操作，即栈，应该与生产者操作的栈是同一个
	public Consumer(SyncStack ss){
		this.ss=ss;
	}
	public void run(){
		for(int i=0;i<5;i++){
			ss.pop();
		try{
				Thread.sleep(3000);//为了调试用，当前线程休眠 3 秒
			}catch(InterruptedException e){
					e.printStackTrace();		
				}
		}
	}
}