阻塞式队列

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而
通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者
要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队
列就是用来给生产者和消费者解耦的

/**
 * 实现阻塞式队列：
 * 1.满足线程安全的生产，消费的功能
 * 2.生产消费达到上限下限时，需要阻塞等待
 */
public class MyBlockingQueue<E> {

    private Object[] items;

    private int takeIndex; //弹出元素的索引
    private int putIndex;  //添加元素的索引
    private int size;  //有效容量

    public MyBlockingQueue(int capacity){
        items = new Object[capacity];
    }

    public synchronized void put(E e) throws InterruptedException {
        while(size == items.length){ //达到上限，需要等待
            wait(); //表示对this对象进行加锁
        }
        putIndex = (putIndex+1)%items.length; // 存放元素的索引，需要满足循环队列索引>数组长度的情况
        items[putIndex] = e; //存放元素
        size++;
        notifyAll();
    }

    //线程间通信，推荐做法：
    //1.while来判断，不要使用if
    public synchronized E take() throws InterruptedException {
        while (size == 0){
            wait();
        }
        takeIndex = (takeIndex + 1)%items.length;
        size--;
        notifyAll();
        return (E)items[takeIndex];
    }

    public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue<Integer> queue = new MyBlockingQueue<>(100);
        for(int i = 0; i < 5; i++){
            final int k = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        for(int j = 0; j < 100; j++){
                            queue.put(k*100+j);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        while (true){
            int num = queue.take();
            System.out.println(num);
        }
    }
}