多线程实例：阻塞队列

阻塞队列是一种具有阻塞功能的队列，满足队列“先进先出”的特点，是一种线性安全的数据结构。当队列为空时，执行出队操作会进行阻塞，直到队列中有元素为止；当队列已经满了，执行入堆操作会进行阻塞，知道队列有空间为止。

阻塞队列的一个典型应用常见就是“生产者消费者”模型。毫无疑问，该模型有两个主体：生产者和消费者。生产者线程负责生产产品，将生产好的产品放进阻塞队列。消费者线程负责消费产品，直接从阻塞队列取产品。

生产者消费者模型具有解耦、平衡速度差异的特点。

解耦：生产者无需关注是谁在消费产品，消费了多少产品，只需关注生产操作即可；消费者无需关注是谁在生产产品，生产了多少产品，只需关注消费操作即可。

平衡速度差异：设想11.11，大量用户向服务器发送了大量的支付请求，一次性将这些请求交给服务器处理，服务器可能会hole不住，因此将这些请求都放进阻塞队列，消费者线程从阻塞队列一个一个地来处理请求就好了。这样就起到了“削峰填谷”的作用，平衡了生产者和消费者之间的速度差异。

标准库中的阻塞队列：

public static void main(String[] args) throws InterruptedException {
    BlockingDeque<String> queue = new LinkedBlockingDeque<>();
    queue.put("hello");
    String s = queue.take();
    System.out.println(s);
}

• BlockingQueue 是一个接口. 真正实现的类是 LinkedBlockingQueue.
• put 方法用于阻塞式的入队列, take 用于阻塞式的出队列.
• BlockingQueue 也有 offer, poll, peek 等方法, 但是这些方法不带有阻塞特性

模拟实现阻塞队列：

• 循环队列+阻塞等待

public class MyQueue {
    public int[] elem = new int[10];
    public int head;
    public int tail;
    public int size;
    public final Object locker = new Object();

    public void put(int val) throws InterruptedException {
        synchronized (locker){
            //队列满了，阻塞等待
            if(size==elem.length){
                locker.wait();
            }
            //一轮循环，让尾指针指向数组下标为0的位置
            if(tail==elem.length){
                tail=0;
            }
            elem[tail++]=val;
            size++;
            //唤醒消费者线程的堵塞等待
            locker.notify();
        }

    }
    public int take() throws InterruptedException {
        synchronized (locker){
            //队列空了，阻塞等待
            if(size==0){
                locker.wait();
            }
            if(head==elem.length){
                head=0;
            }
            int ret = elem[head];
            head++;
            size--;
            //唤醒生产者线程的堵塞等待
            locker.notify();
            return ret;
        }

    }
	//测试代码
    public static void main(String[] args) throws InterruptedException {
        MyQueue queue = new MyQueue();
        //生产者线程
        Thread t1 = new Thread(()->{
            int i=0;
            while (true){
                try {
                    queue.put(i);
                    System.out.println("生产了："+i);
                    i++;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //消费者线程
        Thread t2 = new Thread(()->{
            while(true){
                try {
                    int take = queue.take();
                    System.out.println("消费了："+take);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();

    }
}