生产/消费模型

   生产/消费模型,顾名思义,就是生产者制造产品,消费者购买产品,当然,这其中要有店面作为两者的中介了。在软件开发的过程中就是一个模块作为生产者产生数据，另一个模块作为消费者处理数据，这中间夹着的是缓冲区，用来存放生产者产生的数据以及消费者提取数据的地方。结构如下：

   最开始看到生产/消费模型想到的是生产者产生东西给消费者,那么缓冲区有啥用呢?其实呢,存在即合理嘛,缓冲区的存在自然有其好处的,生产者和消费者不直接依赖可以降低程序的耦合,消费者代码改变不会影响到生产者，再者，生产者和消费者直接关联，生产者生产出来的东西要等到消费者的方法响应之后才能继续太浪费时间了，此外就是可以让两者分隔开来以免生产的太快太慢或者消费的太快太慢不能及时进行处理。大致明白之后还是以代码来说明吧。

//产品类
public class Thing {
	private String name;
	public synchronized void set(String name){
		this.setName(name);
		try{
			Thread.sleep(200);
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	public synchronized void get(){
		try{
			this.getName();
			Thread.sleep(200);
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
	public void setName(String name){
		this.name=name;
	} 
	public String getName(){
		return name;
	}
}


//生产者
public class Producer extends Thread{
	private Thing thing=null;
	public Producer(Thing thing){
		this.thing=thing;
	}
	public void run(){
		super.run();
		while(true){
			for(int i=0;i<50;i++){
				this.thing.set("产品");
				System.out.println("生产产品"+(i+1));
			}
			try{		
				Thread.sleep(1000);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
}

//消费者
public class Customer extends Thread{
	private Thing thing=null;
	public Customer(Thing thing){
		this.thing=thing;
	}
	public void run(){
		super.run();
		while(true){	
			try{
				for(int i=0;i<50;i++){
					this.thing.get();
					System.out.println("消费了产品"+(i+1));
				}		
			}catch(Exception e){
				e.printStackTrace();
			}
			
		}
	}
}

//测试
public class Test {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Thing thing=new Thing();
		new Producer(thing).start();
		new Customer(thing).start();
	}
}

运行结果:

从结果可以看出存在着重复读取和存入的问题,还要继续改进。加入wait()和notify()方法,直接修改产品类Thing,添加标志值,通过判断完成等待和唤醒的操作。
修改后的Thing类如下:

//产品类
public class Thing {
	private String name;
	private boolean flag=true;//设置标志
	public synchronized void set(String name){
		this.setName(name);
		if(flag=false){
			try{
				super.wait();
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		try{
			Thread.sleep(200);
		}catch(Exception e){
			e.printStackTrace();
		}
		flag=false;//改变标志值，表示可以取走
		super.notify();
	}
	public synchronized void get(){
		if(flag){
			try{
				super.wait();
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		try{
			Thread.sleep(200);
		}catch(Exception e){
			e.printStackTrace();
		}
		this.getName();
		flag=true;
		super.notify();
	}
	public void setName(String name){
		this.name=name;
	} 
	public String getName(){
		return name;
	}
}

运行结果:

这样改变之后可以是生产者生产一个,消费者取走一个,但是这样的话生产者等待的时间加长,不利于资源的有效利用,缓冲区的功能未实现,要使用BlockingQueue.

//产品类
public class Thing {
	private String name;
	public void setName(String name){
		this.name=name;
	} 
	public String getName(){
		return name;
	}
}
//生产者
public class Producer extends Thread{
	java.util.concurrent.BlockingQueue<Thing> list;
	public Producer(java.util.concurrent.BlockingQueue<Thing> list){
		this.list=list;
	}
	public void run(){
		super.run();
		int count=1;
			while(true){
				Thing thing=new Thing();
				thing.setName("东西"+count);
				try{		
					list.add(thing);
					System.out.println("生产"+thing.getName());
					count++;
					Thread.sleep(200);
				}catch(Exception e){
					e.printStackTrace();
				}
			}
	}
}

//消费者
public class Customer extends Thread{
	java.util.concurrent.ArrayBlockingQueue<Thing> list;
	public Customer(ArrayBlockingQueue<Thing> list) {
		this.list=list;
	}
	public void run(){ 
		super.run();
		while(true){
			Thing thing;
		try{
			thing=list.take();
			System.out.println("消费了"+thing.getName());
		}catch(Exception e){
			e.printStackTrace();
		}	
		}
	}
}

运行结果：

这个程序还不够完善，还有超出队列长度，多生存者和消费者等等情况，嘻嘻，待续~~~