生产者消费者模式（java）

生产者消费者模式 简单实现与个人理解

简介

：生产者和消费者是两个线程，该模式用于处理两个线程处理一个数据的问题。

具体过程

：生产者生产商品，如汽车。生产的商品放入商品库中（缓冲区），消费者从商品库中取商品。

1. 生产商品，
2. 放入缓冲区，
3. 唤醒消费者，
4. 从缓冲区拿商品，
5. 消费商品，
6. 醒生产者。

代码简介

：
代码包含两个普通类（商品，缓冲区），两个实现了Runnable接口的类（生产者，消费者），和一个包含mian方法的测试类
Car类：普通的类包含一个int型的id属性
CarStock类:包含一个int型的count用于计数、一个可以装car对象的容器类型的属性。方法包括生产和消费的方法。
consume类：消费者类，实现Runnable接口。在构造函数中组合stock类，并在重写run方法中循环consumeCar方法
product类:生产者类，实现Runnable接口。在构造函数中组合stock类，并在重写run方法中循环productCar方法
包含main方法的测试类：创建stock对象，创建consume和product的进程，并调用他们的start方法。

源代码

Car

/**
*类名称：Car
*类描述:Car类
*@version
 */
public class Car {
	private int id;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	@Override
	public String toString() {
		return "Car [id=" + id + "]";
	}

	public Car(int id) {
		super();
		this.id = id;
	}

	public Car() {
		super();
	}
	
}

CarStock

/**
 * 
 */
package org.lanqiao.customProdact;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

/**
* 项目名称：Modes
*类名称：CatStock
*类描述:缓冲区
 * @author ASUS
 *创建时间：2021年7月26日上午11:39:00
*@version
 */
public class CatStock {
//定义数量
	private static int count=0;
	private BlockingQueue<Car> queue;
	
	/**
	 * 生产队列
	 * @param queue
	 */
	public CatStock(BlockingQueue<Car> queue) {
		super();
		this.queue = queue;
	}
	public synchronized void productCar() {
		Car car=new Car();
		try {
			boolean success=this.queue.offer(car,2,TimeUnit.SECONDS);
			if(success) {
				int id=count++;
				car.setId(id);
				System.out.println("生产的编号为："+id+"，库存为："+queue.size());
				Thread.sleep((int)Math.random()*1000);
				notifyAll();
			}else {
				System.out.println("生产失败!!!");
			}
			if(queue.size()>100) {
				System.out.println("生产队列已满，等待。。。");
				wait();
			}
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public synchronized void consumCar() {
		try {
			Car car=queue.poll(2,TimeUnit.SECONDS);
			if(car!=null) {
				Thread.sleep(1000);
				System.out.println("消费了一个汽车，汽车编号："+car.getId()+",库存为："+queue.size());
				notifyAll();
			}else {
				System.out.println("消费失败");
			}
			if(queue.size()<=0) {
				System.out.println("库存已空，请等待");
				wait();
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

CarProduct

/**
 * 
 */
package org.lanqiao.customProdact;

/**
* 项目名称：Modes
*类名称：CarProducter
*类描述:生产者
 * @author ASUS
 *创建时间：2021年7月26日上午11:38:42
*@version
 */
public class CarProducter implements Runnable{
	private CatStock carStock;
	private volatile boolean isRunning=true;
	public CarProducter(CatStock carStock) {
		super();
		this.carStock = carStock;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(isRunning) {
			carStock.productCar();
		}
	}
	public void stop() {
		this.isRunning=false;
	}

}

CarConsume

/**
 * 
 */
package org.lanqiao.customProdact;

/**
* 项目名称：Modes
*类名称：CarConsumer
*类描述:消费者
 * @author ASUS
 *创建时间：2021年7月26日上午11:38:05
*@version
 */
public class CarConsumer implements Runnable{
	private CatStock carStock;
	
	public CarConsumer(CatStock carStock) {
		super();
		this.carStock = carStock;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			carStock.consumCar();
		}
		
	}

}

Demo

/**
 * 
 */
package org.lanqiao.customProdact;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

/**
* 项目名称：Modes
*类名称：demo1
*类描述:测试类
 * @author ASUS
 *创建时间：2021年7月26日上午9:53:39
*@version
 */
public class Demo1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		LinkedBlockingQueue<Car> queue= new LinkedBlockingQueue<Car>(100);
		CatStock stock=new CatStock(queue);
		
		CarConsumer tc=new CarConsumer(stock);
		CarProducter tp=new CarProducter(stock);
		
		CarConsumer tc2=new CarConsumer(stock);
		CarProducter tp2=new CarProducter(stock);
		
//		new Thread(tc).start();
//		new Thread(tc2).start();
//		new Thread(tp2).start();
//		new Thread(tp).start();
				
		ExecutorService cachedThreadPool=Executors.newCachedThreadPool();
		cachedThreadPool.execute(tc2);
		cachedThreadPool.execute(tc);
		cachedThreadPool.execute(tp);
		cachedThreadPool.execute(tp2);
		
	}

}