多线程 工厂 > 商店(仓库) > 客户模式 消费者模式 实现多仓库 多产品 多工厂 多客户

import java.util.concurrent.ConcurrentHashMap;

public class Producer extends Thread{
	private String name;

	private Stock[] stocks; //工厂对应的仓库
	private Product[] products; //工厂主要生产的产品
	private ConcurrentHashMap<Product,Boolean> producibility;

	public Producer(String name){
		this.name = name;
	}

	public void init(Stock ... stocks){
		this.stocks = stocks;
	}

	public void init(Product ... products){
		this.products = products;
	}

	public void run(){
		assert stocks != null && products != null;
		for(int i = 0 ; i < stocks.length ; i ++){
			for(int j = 0 ; j < products.length ; j ++){
				
				producibility = stocks[i].getProducibility();
				if(producibility.get(products[j]) == null){
					stocks[i].inStock(products[j]);
				}
				
				while(producibility.get(products[j])){
					stocks[i].inStock(products[j]);
				}
			}
		}
	}
}

public class Customer extends Thread{
	private String name;
	private Stock stock;
	private Product[] products;

	public Customer(String name){
		this.name = name;
	}


	public void shopping(Stock stock,Product ... products){
		this.stock = stock;
		this.products = products;
	}

	public void run(){
		for(Product product : products){
			stock.outStock(product);
		}
	}
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.HashMap;
import java.io.BufferedReader;
import java.io.BufferedInputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Set;


public final class Stock{
	private ConcurrentHashMap<Product,Integer> inStock = new ConcurrentHashMap<>();//库存数量,采用同步HashMap来处理.
	private HashMap<Product,Integer> MAXSTOCK = new HashMap<>();//库存中允许的最大库存,当到达这个库存的时候通知工厂停止生产
	private HashMap<Product,Integer> MINSTOCK = new HashMap<>();//库存中允许的最低库存,当到达这个临界点的时候通知工厂安排生产

	private ConcurrentHashMap<Product,Boolean> producibility = new ConcurrentHashMap<>();//某个产品是否需要生产
	private ConcurrentHashMap<Product,Boolean> merchantability = new ConcurrentHashMap<>();//当某个产品库存数量为0的时候设置为false 这个变量为了多仓库,寻找对应产品是否有可销售库存.

	private String name;

	private Stock(){
		//default constructor.
		//forbit
	}

	public Stock(String name){
		this.name = name;
	}

	@Override
	public String toString(){
		return name;
	}

	public ConcurrentHashMap<Product,Boolean> getProducibility(){
		return producibility;
	}

	public void showInStock(){
		Set<Product> products = inStock.keySet();
		for(Product product : products){
			System.out.println(product + ":" + inStock.get(product));
		}
	}


	public void inStock(Product product){//产品入库
		synchronized(product){
			if(inStock.containsKey(product)){//如果仓库中已经有该产品
				assert MAXSTOCK.containsKey(product) && MINSTOCK.containsKey(product) && producibility.containsKey(product) && merchantability.containsKey(product);
				inStock.put(product,inStock.get(product) + 1);//该产品库存数量增加1
				if(inStock.get(product) >= MAXSTOCK.get(product)){//如果大于等于该产品库存上限,则该通知工厂该产品不生产.
					producibility.put(product,false);
				}
				product.notifyAll();
				return;
			}
			try{
				//System.out.printf("product:[%s] not is the store:%s.\n",product.getName(),this);
				//System.out.printf("set the cost of product:[%s]:",product.getName());
				//double cost = Double.valueOf(reader.readLine().trim());
				double cost = 2.2;
				//System.out.printf("set the price of product:[%s]:",product.getName());
				//double price = Double.valueOf(reader.readLine().trim());
				double price = 3.5;
				product.setCost(cost).setPrice(price);
				inStock.put(product,1);
				//System.out.printf("set the maxstore of product:[%s]:",product.getName());
				//int maxStock = Integer.valueOf(reader.readLine().trim());
				int maxStock = 8;
				assert maxStock > 0;
				MAXSTOCK.put(product,maxStock);//设置该产品最大库存量.
				//System.out.printf("set the minstore of product:[%s]:",product.getName());
				//int minStock = Integer.valueOf(reader.readLine().trim());
				int minStock = 2;
				assert minStock >= 0 && minStock < maxStock;
				MINSTOCK.put(product,minStock);//设置该产品最小库存量.
				merchantability.put(product,true);//可销售.
				//System.out.printf("Product:[name:%s,price:%2f] in Stock:%s merchantability\n",product.getName(),product.getPrice(),this);
				if(maxStock == 1){
					producibility.put(product,false);
					product.notifyAll();
					return;
				}
				producibility.put(product,true);
				product.notifyAll();
			}catch(Exception e){
				e.printStackTrace();
				System.exit(1);
			}
			
		}
	}

	public void outStock(Product product){
		synchronized(product){
			if(!inStock.containsKey(product)){
				System.out.printf("Not product:[%s] in store:%s\n",product.getName(),this);
				return;
			}
			assert MAXSTOCK.containsKey(product) && MINSTOCK.containsKey(product) && producibility.containsKey(product) && merchantability.containsKey(product);
			int instock = 0;
			while((instock = inStock.get(product)) == 0){
				merchantability.put(product,false);
				try{
					System.out.printf("product:[name:%s,price:%2f] stock=0 wait()\n",product.getName(),product.getPrice());
					product.wait();//无库存,释放锁.等待生产.
				}catch(InterruptedException e){
					e.printStackTrace();
					System.exit(1);
				}
			}
			//到达这里说明仓库对应产品数量已经大于0.
			inStock.put(product,instock - 1);
			
			if(instock - 1 <= MINSTOCK.get(product)){
				producibility.put(product,true);
			}

			System.out.printf("product:[name:%s,price:%2f] outStock.\n",product.getName(),product.getPrice());

		}
	}

	

	private BufferedReader reader = new BufferedReader(
										new InputStreamReader(
											new BufferedInputStream(
												System.in)));
}

import java.io.Serializable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Product implements Serializable{
	private static final long serialVersionUID = 9L;

	private String name;
	private double price;
	private double cost;

	public Product(String name){
		this.name = name;
	}

	public Product(String name,double price,double cost){
		this.name = name;
		this.price = price;
		this.cost = cost;
	}

	@Override
	public int hashCode(){
		return name.hashCode() * 3;
	}

	@Override
	public String toString(){
		return String.format("[name:%s,price:%f,cost:%f]",name,price,cost);
	}

	public String toString1(){
		//for producer
		return String.format("[name:%s,cost:%s]",name,cost);
	}

	public String toString2(){
		//for customer
		return String.format("[name:%s,price:%s]",name,price);
	}

	public String getName(){
		return name;
	}

	public double getPrice(){
		return price;
	}

	public double getCost(){
		return cost;
	}

	public synchronized Product setPrice(double price){
		this.price = price;
		return this;
	}

	public synchronized Product setCost(double cost){
		this.cost = cost;
		return this;
	}




//-------------------------------------------------------------------------------------------
	private void readObject(ObjectInputStream in)throws IOException,ClassNotFoundException{
		in.defaultReadObject();
		System.out.println("Read:" + this);
	}

	private void writeObject(ObjectOutputStream out)throws IOException{
		out.defaultWriteObject();
		System.out.println("Write:" + this);
	}
}

public class Test{
	public static void main(String[] args){
		Stock stock = new Stock("京东");
		Product product1 = new Product("电视机");
		Product product2 = new Product("洗衣机");
		Producer producer = new Producer("京东工厂");
		producer.init(product1,product2);
		producer.init(stock);
		producer.start();
		Customer customer = new Customer("张三");
		customer.shopping(stock,product1,product2,product1,product2,product1,product2,product1,product2);
		customer.start();

		stock.showInStock();
		try{
			Thread.sleep(200);
		}catch(InterruptedException e){
			e.printStackTrace();
			return;
		}
		
		
	}
}