生产 消费者模型

public class Test_Cus_Pro {
    /**
     * 模拟出生产者，消费者一起运行
     * 2个生产者，2个消费者
     * 涉及一个容器，生产者可以不停的向容器中生产商品，消费者可以不停的从容器中消费
     * 如果生产者比较快，容易不能溢出；如果消费者比较快，能正常等待
     */

    public static void main(String[] args) {
        Test_Cus_Pro test = new Test_Cus_Pro();
        Basket b = new Basket();
        Produce p = new Produce(b);
        Customer c = new Customer(b);

        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);

        t1.start();
        t2.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


    //商品
   class ManTou {
        public ManTou() {

        }

        public ManTou(int id) {
            this.id = id;
        }

        public int getId() {
            return id;
        }

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

        private int id;

        @Override
        public String toString() {
            return "ManTou{" +
                    "id=" + id +
                    '}';
        }
    }

    //容器
    class Basket {
        private ManTou[] mts;
        private int index = 0;

        public Basket() {
            mts = new ManTou[10];
        }

        public synchronized void fang(ManTou mt) {
            while (index > mts.length - 1) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            /**
             * 保存至mts[index],此时mts[index+1]没有存储元素
             * 故消费的时候，消费的是mts[index],故需要先执行i--
             */
            mts[index] = mt;
            index++; //
            notifyAll();
        }

        public synchronized ManTou na() {//?
            while (index <= 0) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            index--;
            notifyAll();
            return mts[index];

        }
    }

    class Produce implements Runnable {
        private Basket bas;//私有属性
        public Produce(Basket bas) {  //构造方法给篮子赋值
            this.bas = bas;
        }

       int i = 0;

        @Override
        public void run() {
                for(;i<100;i++){
                    ManTou mt = new ManTou(i);
                    bas.fang(mt);
                    System.out.println("生产者生成了一个馒头---->" + mt.getId());
                    try {
                        Thread.sleep(10);//sleep是静态方法，最好不要用Thread的实例对象调用它，
                        // 因为它休眠的始终是当前正在运行的线程，而不是调用它的线程对象，它只对正在运行的线程对象有效
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
     }
    }

    class Customer implements Runnable {
        private Basket bas;

        //构造方法给篮子赋值
        public Customer(Basket bas) {
            this.bas = bas;
        }


        @Override
        public void run() {
            while (true) {
                ManTou mt = bas.na();
                System.out.println("消费者消费了一个馒头-->" + mt.getId());
                try {
                    Thread.sleep(9);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }