生产者消费者模型

参照这篇文章
生产者消费者问题：
生产者和消费者在同一时间段内共用一个工厂（存储空间），生产者往工厂里添加商品，消费者从工厂里取走商品。

• 当工厂满了，生产者阻塞等待
• 当工厂空了，消费者阻塞等待

public class ProducerAndConsumer {
    public static void main(String[] args) {
        Factory factory = new Factory(10);

        Producer producer = new Producer(factory);
        //Producer producer2 = new Producer(factory);
        Consumer consumer = new Consumer(factory);

        producer.start();
        //producer2.start();
        consumer.start();
    }


    /**
     * 工厂模型，表示公共资源
     */
    static class Factory{
        int max;//工厂的最大物品数
        int num;//当前工厂当中还有多少物品

        public Factory(int max) {
            this.max = max;
        }

        /**
         * 生产
         */
        synchronized void add(){
            //如果工厂没有满，就生产物品
            if (num < max){
                num++;
                System.out.println("生产了一件商品，现在工厂中还有：" + num + "件物品");
                //唤醒等待的消费者来消费
                notifyAll();
            }else {
                try {
                    //工厂满了，生产者等待
                    wait();
                    System.out.println("工厂满了，生产者等待");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        synchronized void remove(){
            //如果工厂有物品
            if (0 < num){
                num--;
                System.out.println("消费了一件物品，还剩下：" + num + "件物品");
                //唤醒等待的生产者来生产物品
                notifyAll();
            }else {
                try {
                    //没有东西可以被消费了，该线程等待，等到生产者来生产
                    wait();
                    System.out.println("工厂没东西了，消费者等待");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 生产者
     */
    static class Producer extends Thread{
        Factory factory;

        public Producer(Factory factory) {
            this.factory = factory;
        }

        @Override
        public void run() {
            while (true){
                //一直生产
                try{
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                factory.add();
            }
        }
    }

    /**
     * 消费者
     */
    static class Consumer extends Thread{
        Factory factory;

        public Consumer(Factory factory) {
            this.factory = factory;
        }

        @Override
        public void run() {
            while (true){
                //一直消费
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                factory.remove();
            }
        }
    }
}