生产者消费者模式浅析示例

生产者消费者模式个人理解

java开发中常用的一种设计模式，核心设计思想，抽象生活中的工作方式，工厂负责生产商品，消费者负责消费商品，仓库负责存储商品，当仓库库存满的时候，

工厂暂停生产，当库存没有的时候，消费者就不能消费等待有新的商品入库。

这样就包括了几点

1.商品对象

2.仓库对象，负责接收商品与发货商品

3.生产者负责生产商品

4.消费者负责消费生产

这样对于java来说实现逻辑就比较明朗了，下面就直接附代码非大家参考了，多多拍砖

package com.sh.procon;

/**
 * 生产目标对象/消费目标对象
 * @author Administrator
 *
 */
public class MessageData {
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "messageid="+this.messageid+",obj="+this.obj;
	}
	private String messageid;
	private Object obj;
	public MessageData(String id,Object object){
		this.messageid =id;
		this.obj = object;
	}
	public String getMessageid() {
		return messageid;
	}
	public void setMessageid(String messageid) {
		this.messageid = messageid;
	}
	public Object getObj() {
		return obj;
	}
	public void setObj(Object obj) {
		this.obj = obj;
	}
	

}

package com.sh.procon;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;



/**
 * 仓库类实现
 * 生产者消费者模式说明：
  1.生产者只在仓库未满时进行生产，仓库满时生产者进程被阻塞；
  2.消费者只在仓库非空时进行消费，仓库为空时消费者进程被阻塞；
  3.当消费者发现仓库为空时会通知生产者生产；
  4.当生产者发现仓库满时会通知消费者消费；
 * @author Administrator
 *
 */
public class SyncStack {
	
	private BlockingQueue<MessageData> queue = new LinkedBlockingQueue<MessageData>(100); //
	
	private static final int maxSize = 2; //最大仓库容量
	
	public synchronized void product(MessageData data){
		
		while(queue.size()>maxSize){
			System.out.println("当前容量:"+queue.size()+",最大容量:"+maxSize+",超过容量暂停生产");
			try {
				//大于最大容量对象wait
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		try {
			queue.put(data);
			System.out.println("生产数据="+data.toString());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		notifyAll();
	}
	
	public synchronized MessageData consumer(){
		
		while(queue.size()<=0){
			System.out.println("当前容量:"+queue.size()+",最大容量:"+maxSize+",未生产产品暂停消费");
			//如果仓库为0则暂停消费
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		MessageData data= null;
		try {
			 data= queue.take();//从仓库开始消费
			 System.out.println("消费数据="+data.toString());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.notifyAll();
		
		return data;
	}
	

}

package com.sh.procon;

public class Product implements Runnable{
	private MessageData data;
	private SyncStack stack;
	
	Product(MessageData data,SyncStack stack){
		this.data = data;
		this.stack = stack;
	}

	@Override
	public void run() {
		//给仓库生产对象
		stack.product(data);
		System.out.println("Product生产数据="+data.toString());
		
	}
	

}

package com.sh.procon;

public class Consumer implements Runnable {
	
	private MessageData data;
	private SyncStack stack;
	
	Consumer(SyncStack stack){
		this.stack = stack;
	}

	public MessageData getData() {
		return data;
	}

	public void setData(MessageData data) {
		this.data = data;
	}

	@Override
	public void run() {
		
		data = stack.consumer();
		System.out.println("Consumer消费数据="+data.toString());
	}
	

}

package com.sh.procon;


public class Test {
	
	public static void main(String[] args) {
		MessageData data1 = new MessageData("msid00001","Object 000001");
		MessageData data2 = new MessageData("msid00002","Object 000002");
		MessageData data3 = new MessageData("msid00003","Object 000003");
		MessageData data4 = new MessageData("msid00004","Object 000004");
		MessageData data5 = new MessageData("msid00005","Object 000005");
		
		
		SyncStack statck = new SyncStack();
		
		Thread product1 = new Thread(new Product(data1,statck));
		Thread product2 = new Thread(new Product(data2,statck));
		Thread product3 = new Thread(new Product(data3,statck));
		Thread product4 = new Thread(new Product(data4,statck));
		Thread product5 = new Thread(new Product(data5,statck));
		
		product1.start();
		product2.start();
		product3.start();
		product4.start();
		product5.start();
		
		/**
		 * 
		 */
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		/**
		 * 消费者开始消费
		 */
		for(int i=0;i<10;i++){
			Thread consumer = new Thread(new Consumer(statck));
			consumer.start();
		}
		
		
	}

}

运行结果：

生产数据=messageid=msid00001,obj=Object 000001
生产数据=messageid=msid00004,obj=Object 000004
Product生产数据=messageid=msid00001,obj=Object 000001
生产数据=messageid=msid00002,obj=Object 000002
Product生产数据=messageid=msid00002,obj=Object 000002
Product生产数据=messageid=msid00004,obj=Object 000004
当前容量:3,最大容量:2,超过容量暂停生产
当前容量:3,最大容量:2,超过容量暂停生产
消费数据=messageid=msid00001,obj=Object 000001
Consumer消费数据=messageid=msid00001,obj=Object 000001
生产数据=messageid=msid00005,obj=Object 000005
Product生产数据=messageid=msid00005,obj=Object 000005
消费数据=messageid=msid00004,obj=Object 000004
Consumer消费数据=messageid=msid00004,obj=Object 000004
消费数据=messageid=msid00002,obj=Object 000002
Consumer消费数据=messageid=msid00002,obj=Object 000002
消费数据=messageid=msid00005,obj=Object 000005
Consumer消费数据=messageid=msid00005,obj=Object 000005
当前容量:0,最大容量:2,未生产产品暂停消费
当前容量:0,最大容量:2,未生产产品暂停消费
当前容量:0,最大容量:2,未生产产品暂停消费
生产数据=messageid=msid00003,obj=Object 000003
Product生产数据=messageid=msid00003,obj=Object 000003
消费数据=messageid=msid00003,obj=Object 000003
Consumer消费数据=messageid=msid00003,obj=Object 000003
当前容量:0,最大容量:2,未生产产品暂停消费
当前容量:0,最大容量:2,未生产产品暂停消费
当前容量:0,最大容量:2,未生产产品暂停消费
当前容量:0,最大容量:2,未生产产品暂停消费
当前容量:0,最大容量:2,未生产产品暂停消费