生产者消费者模式案例

生产者：汽车厂商
消费者：小明
小明需要买一辆车，如果厂家有的话，就可以直接买。如果没有的话，小明就需要等待（wait）。等厂家生产完之后，就会唤醒小明，告诉小明来提车。如果来买的人多了就可以使用循环操作。
案例：

package com.qf.c_shenchanhzexiaofeizhe;

//为啥要写这个类 商品类
class Goods {
    private String name;//商品的名字
    private double price;//商品的价格
    private boolean isProduct;//商品是否需要生产
    //true需要生产    false 不需要生产


    public Goods(String name, double price, boolean isProduct) {
        this.name = name;
        this.price = price;
        this.isProduct = isProduct;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public boolean isProduct() {
        return isProduct;
    }

    public void setProduct(boolean product) {
        isProduct = product;
    }
}

class Customer implements Runnable {//消费者线程
    private Goods goods;

    public Customer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        //消费者一直消费  生产者一直生产
        while (true) {
            synchronized (goods) {
                //需要一直消费 判断商品是否有无
                // //true需要生产    false 不需要生产
                if (!goods.isProduct()) {
                    //不需要生产直接购买的
                    System.out.println("消费者购买:" + goods.getName() + ",价格为:"+ goods.getPrice());
                    //购买完以后，商品没了，商品标记为true
                    goods.setProduct(true);
                    //唤醒生产者  让其生产
                    goods.notify();
                } else {
                    //需要生产  消费者线程等待
                    try {
                        goods.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
class Productor implements Runnable {//生产者线程
    private Goods goods;

    public Productor(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        int count = 0;

        while (true) {
            try {
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (goods) {
                // true需要生产    false 不需要生产
                if (goods.isProduct()) {//true
                    //造车，如果是奇数的话，造玛莎拉蒂  如果是偶数的话，造劳斯莱斯
                    if (count % 2 == 0) {
                        //偶数
                       goods.setName("劳斯莱斯");
                       goods.setPrice(8.9);

                    } else {
                        //奇数
                        goods.setName("玛莎拉蒂");
                        goods.setPrice(7.6);
                    }
                    //生产者生产者完以后，将isProcut标记为
                    goods.setProduct(false);
                    System.out.println("生产者生产了:" + goods.getName() + ",价格为:" + goods.getPrice());
                    count++;
                    //生产者生产完以后 唤醒消费者。
                    goods.notify();
                } else{
                    //不需要生产的
                    try {
                        goods.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Goods goods = new Goods("红旗", 9.9, false);

        Customer customer = new Customer(goods);
        Productor productor = new Productor(goods);
        new Thread(customer).start();
        new Thread(productor).start();


        /**
         * 消费者购买:红旗,价格为:9.9
         * 生产者生产了:劳斯莱斯,价格为:8.9
         * 消费者购买:劳斯莱斯,价格为:8.9
         * 生产者生产了:玛莎拉蒂,价格为:7.6
         * 消费者购买:玛莎拉蒂,价格为:7.6
         * 生产者生产了:劳斯莱斯,价格为:8.9
         * 消费者购买:劳斯莱斯,价格为:8.9
         * 生产者生产了:玛莎拉蒂,价格为:7.6
         * 消费者购买:玛莎拉蒂,价格为:7.6
         * 生产者生产了:劳斯莱斯,价格为:8.9
         */
    }
}