Java中高级高并发与多线程系列（六）：经典的生产者-消费者模型

首先声明，本系列文章分享都是我自己的学习理解以后，原创手敲，可能包含错误的观点和理解，仅供参考，如遇错误的地方欢迎指正。

上一篇我们学会了 synchronized 线程同步，到这里已经可以做一些东西了，最为经典的就是生产者-消费者模型，一个生产者不停的生产资源，一个消费者不停的消费资源，两个线程模拟这样的关系，好比厨师和传菜工，厨师不停的炒菜，传菜工看到有菜了就端走。

多线程系列全部演示代码公开在：https://github.com/renfei/demo/tree/master/java/ConcurrentDemo

生产者与消费者设计

首先我们需要一个仓库对象来存储生产者的生产结果，消费者去仓库拿走结果，我们还是用苹果的案例，新建一个仓库：

/**
 * 仓库，装载苹果的内存空间
 */
class Warehouse {
    private Apple apple;
    // 优雅的停止线程标识，仓库是不是还在营业
    private boolean run = true;
    static class Apple {
    }
    public synchronized void set(Apple apple) {
        if (this.apple != null) {
            // 无法放入，需要被消费
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            // 放入仓库，唤醒等待的线程
            this.apple = apple;
            super.notify();
        }
    }
    public synchronized Apple get() {
        if (this.apple == null) {
            // 仓库空了，无法消费，需要生产
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            return this.apple;
        } finally {
            // 被消费，唤醒等待线程
            this.apple = null;
            super.notify();
        }
    }
    public boolean isRun() {
        return run;
    }
    public void setRun(boolean run) {
        this.run = run;
    }
}

生产者

生产者一直做生产工作，往仓库里送苹果：

/**
 * 生产者，苹果没了就生产
 */
class Producer implements Runnable {
    private Warehouse warehouse;
    public Producer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }
    @Override
    public void run() {
        while (warehouse.isRun()) {
            try {
                // 模拟延迟，模拟生产比消费快一点
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("生产者：生产一个苹果");
            this.warehouse.set(new Warehouse.Apple());
        }
    }
}

消费者

消费者一直从仓库里拿走苹果：

/**
 * 消费者，有苹果就消费
 */
class Consumer implements Runnable {
    private Warehouse warehouse;
    public Consumer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }
    @Override
    public void run() {
        while (warehouse.isRun()) {
            try {
                // 模拟延迟，模拟消费比生产慢一点
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.warehouse.get();
            System.out.println("消费者：消费一个苹果");
        }
    }
}

让他们运行起来：

// 装载苹果的仓库内存空间
Warehouse warehouse = new Warehouse();
// 生产者开始生产
Thread threadProducer = new Thread(new Producer(warehouse), "Producer");
// 消费者开始消费
Thread threadConsumer = new Thread(new Consumer(warehouse), "Consumer");
threadProducer.start();
threadConsumer.start();
try {
    // 让子线程们执行 4 秒
    Thread.sleep(4000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
// 优雅的停止线程，仓库停止营业了
warehouse.setRun(false);

完整代码公开在：https://github.com/renfei/demo/blob/master/java/ConcurrentDemo/src/main/java/net/renfei/demo/concurrent/ProducerConsumerDemo.java

总结

在这个案例中，我们使用了线程通知机制，在仓库那里使用了 wait() 和 notify()，也许你会有疑问，唤醒的如果是自己呢？这个是唤醒所有子线程，但咱们还有个 if 判断，如果自己唤醒了自己 if 判断以后，还是会继续 wait()，除非条件满足才进行自己的逻辑。

另外我们使用了更优雅的线程停止方式，那就是根据条件判断，如果直接停止主线程，子线程还有逻辑没有运行完，就会造成数据错误，如果使用条件来控制线程的退出，这样可以保证子线程可以运行一次完整的逻辑再退出。