什么是生产者消费者模型

我们可以把这个模型想象成工厂里的两条流水线，我们管他们叫生产者流水线和消费者流水线，生产者流水线生产出来的产品给消费者流水线使用，其中生产者流水线先把生产出来的产品放在仓库，然后消费者流水线再去仓库拿。这个仓库就叫做阻塞队列。

那么，这个仓库的实现有什么要求呢？
第一，仓库满的时候，不能继续往里放了，生产者流水线要停止生产。
第二，仓库空的时候，拿不出来了，消费者流水线要停止取商品。
第三，生产者流水线和消费者流水线都可以使用仓库。也就是说仓库是共享变量，要注意线程安全。

下面我们先来设计一下这个仓库（阻塞队列）：

关于阻塞队列的设计，有几点需要我们思考：
①为什么要给阻塞队列容量的限制？如果生产者生成的效率比消费者消费的效率快，那么生产者产生的“产品”会不断的在队列中累积起来，最终耗尽内存。如果使用有界队列，那么当队列满时，生产者会阻塞并且不能继续工作，而消费者可以赶上工作进度。
②如何保证阻塞队列的线程安全？由于生产者和消费者都是对阻塞队列进行修改操作，所以我们既需要保证操作的可见性又需要保证原子性，实现的方法有很多种：一种是将阻塞队列设计成线程安全的类，另一种是将生产者和消费者对阻塞队列的操作设计成原子操作。

③阻塞队列是如何实现阻塞的？wait/notify 或者 await/signal都可以实现阻塞与唤醒操作。

生产者消费者模型的代码实现
将阻塞队列设计成线程安全的类

import java.util.LinkedList;
import java.util.Queue;

public class BlockQueueplus {
    Queue<Integer> queue = new LinkedList();
    int capacity ; //阻塞队列的容量

    public BlockQueueplus(int capacity) {
        this.capacity = capacity;

    }

    /**
     * 堆代码 duidaima.com
     * 将数据放入阻塞队列中
     * @param i 放入的元素
     * @throws InterruptedException
     */
    public synchronized void put(Integer i) throws InterruptedException {
        while(capacity <= queue.size()){
            wait();
        }
        queue.offer(i);
        System.out.println(Thread.currentThread().getName() + "生产了value, value的当前值是" + i );
        notify();
    }

    /**
     * 从阻塞队列中取出数据
     * @return
     * @throws InterruptedException
     */
    public synchronized int take() throws InterruptedException {
        if(size() == 0){
            wait();
        }
        Integer result = queue.poll();
        System.out.println(Thread.currentThread().getName() + "消费了value, value的当前值是" + result );
        notify();
        return result;
    }

    public int size(){
        return queue.size();
    }

    public Boolean isEmpty(){
        return queue.isEmpty();
    }

    public Boolean isFull(){
        return this.size()==this.capacity;
    }

}

synchronized关键字用在方法上的作用
有的同学可能不懂synchronized关键字用在方法上有什么作用，我来讲解一下：
在我的BlockQueueplus类中，put()和take()都添加了synchronized关键字，当进入synchronized修饰的方法时，锁住的是当前实例类，所以当调用put()方式时，put()方法拿到了当前实例的锁，take()想运行也需要拿到锁，就要等待put()方法运行完释放锁。所以就实现了put操作和take操作的互斥。

wait和notify的使用
首先呢，Java 中每个对象都有一把称之为 monitor 监视器的锁，调用synchronized方法时，会获取monitor锁。当调用wait方法时，会释放monitor锁。在我的BlockQueueplus类中，当队列满时，put方法会调用wait方法，进入阻塞，此时take方法就可以获取锁，运行取操作。take操作在执行完取操作之后，会调用notify()方法，通知一个正在wait阻塞中的线程让它继续运行。

生产者线程与消费者线程
用Work把阻塞队列封装一下，只提供插入和取两种方法。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Work{
    private static BlockQueueplus blockQueueplus = new BlockQueueplus(100);
    public void set(int i)
    {
            try {
                blockQueueplus.put(i);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
    }

    public void get() 
    {
        try {
            Integer i = blockQueueplus.take();
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
}

测试类
开启两个线程，生产者不停的往阻塞队列中插入数据，消费者不停的从阻塞队列中取数据

class WorkTest {
    public static void main(String[] args) {
        Work work = new Work();
        Runnable producerRunnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < Integer.MAX_VALUE; i++)
                    work.set(i);
            }
        };
        Runnable customerRunnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < Integer.MAX_VALUE; i++)
                    work.get();
            }
        };
        Thread ProducerThread = new Thread(producerRunnable);
        ProducerThread.setName("Producer");
        Thread ConsumerThread = new Thread(customerRunnable);
        ConsumerThread.setName("Consumer");
        ProducerThread.start();
        ConsumerThread.start();
    }
}

运行结果：

从运行结果中可以发现，生产者线程与消费者线程交接的时候，他们生产的数和消费的数的差正好为99，也证明了阻塞队列设计的成功。

还可以改进的地方
生产者线程可能是多个，消费者线程也可以是多个，如果继续使用暴力的wait和notify，就有可能会出现生产者A唤醒生产者B的错误，我们可以尝试使用await和signal来优雅的唤醒需要唤醒的线程。