生产者消费者设计模式--例子

生产者：

作用是生产商品

生产逻辑：通过一个生产标记，判断是否需要生产产品

​ 如果需要生产：生产产品，并通知消费者消费产品

​ 如果不需要生产：等等

消费者：

作用：消费产品

消费逻辑：判断是否有足够的产品可以消费

​ 如果可以消费：获取产品，进行消费，并通知生产者已经消费

​ 如果不可消费：等待

• 生产和消费是同时进行的；
• 需要两个线程，一个线程生产，一个线程消费；
• 需要一个产品池存放当前生产的商品，并且消费者也从该产品池拿出产品进行消费（这个商品池就是多线程中所说的临界资源）

设计实例1：使用多线程实现

产品类：表示生产和消费的产品

package ProductorAndConsumer;

//产品类，表示生产着生产出来的产品
public class Product {
	private String name;  //设置产品的名字
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public Product(String name) {
		this.name=name;
	}
}

产品池：放所有产品

package ProductorAndConsumer;

import java.util.LinkedList;
import java.util.List;

//产品池，存放生产者生产的产品，消费者从该产品池中拿出产品消费
public class ProductPool {
	//存储所有的产品的集合，生产者生产产品，往这个集合中添加元素；消费者消产品，从这个集合中取出元素
	private List<Product> productList;
	//产品池的最大容量
	private int maxSize;
	
	public ProductPool(int maxSize){
		//对产品池进行实例化
		this.productList=new LinkedList<Product>();
		this.maxSize=maxSize;
	}
	/*
	 * 生产者将生产好的产品放入产品池
	 */
	public synchronized void push(Product product) {
		//如果产品池满了，那么生产者此时不需要生产产品了
		if(this.productList.size()==maxSize) {
			//等待
			try {
				this.wait();
			} 
			catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		//如果产品池没满，将继续生产，产品放入集合中
		this.productList.add(product);
		//通知其他人，有产品可以消费了
		this.notifyAll();
	}
	
	/*
	 * 消费者将从商品池中取出一件商品
	 */
	public synchronized Product pop() {
		//如果没有商品消费
		if(this.productList.size()==0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		//还有产品，继续消费
		Product product=this.productList.remove(0);
		//通知其他人，我取出了一件产品
		this.notifyAll();
		
		return product;
	}
}

生产者生产逻辑

package ProductorAndConsumer;

public class Productor extends Thread{
	//定义一个产品池
	private ProductPool pool;
	public Productor(ProductPool pool) {
		this.pool=pool;
	}
	//生产产品
	@Override
	public void run() {
		while(true) {
			String name=(int)(Math.random()*100)+"号产品";
			System.out.println("生产了一件产品"+name);
			Product product=new Product(name);
			//将产品放入产品池
			this.pool.push(product);
		}
	}
}

消费者消费逻辑

package ProductorAndConsumer;

public class Consumer extends Thread{
	//产品池
	private ProductPool pool;
	public Consumer(ProductPool pool) {
		this.pool=pool;
	}
	//消费者消费产品
	@Override
	public void run() {
		while(true) {
			Product product=this.pool.pop();
			System.out.println("消费者消费了一个产品"+product.getName());
		}
	}
}

主程序

package ProductorAndConsumer;

public class Program {
	public static void main(String[] args) {
		//实例化一个产品池，设置能存放15个产品
		ProductPool pool=new ProductPool(15);
		
		//实例化一个生产者
		new Productor(pool).start();
		//实例化一个消费者
		new Consumer(pool).start();
	}
}

运行结果：需要手动停止

多线程设计实例2：使用BlockingQueue实现

BlockingQueue具有一个特征：

• 当生产者试图向BlockingQueue中放入元素时，如果该对列已满，则线程被阻塞；
• 当消费者试图从BlockingQueue中取出元素时，如果该队列已空，则该线程被阻塞

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ProducerConsumer {
	//新建一个BlockingQueue，其容量为5
	private static BlockingQueue<String> queue=new ArrayBlockingQueue<String>(5);
	
	/*新建一个内部类，表示生产者
	 	生产者生产产品，并把产品放入queue对列中
	 */
	private  static class Producer extends Thread{
		@Override
		public void run() {
			try {
				queue.put("product");  //放入产品
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("正在生产产品");
		}
	}
	/*
	 *  新建一个内部类，表示消费者
	 *  	消费者消费产品，从queue中取出产品
	 */
	private static class Consumer extends Thread{
		@Override
		public void run() {
			try {
				String product=queue.take();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} //取出产品
			System.out.println("正在消费产品");
		}
	}
	public static void main(String[] args) {
		//新建生产者
		for(int i=0;i<6;i++) {
			Producer producer=new Producer();
			producer.start();
		}
		//新建消费者
		for(int i=0;i<3;i++) {
			Consumer consumer=new Consumer();
			consumer.start();
		}
	}
}