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;
}
}
}