阻塞队列

1. 概念

什么是阻塞队列呢? 它本质上就是一种队列, 遵循先进先出, 后进后出的原则.

如果出队时, 队列为空, 就会使当前线程进入阻塞状态, 直到有新的元素进入才会继续执行.

同样的, 入队时队列为满, 这时线程也会阻塞, 直到队列不满才继续执行.

生产者消费者模型

生产者消费者模型, 在开发中很有意义.

1. 解耦合

实际开发中, 经常会涉及到 "分布式系统", 服务器整个功能不是由一个服务器全部完成的, 而是每个服务器负责一部分功能, 再通过服务器之间的网络通信, 最终实现整个功能.

这个模型中, A 和 B , A 和 C 之间耦合性就是比较强的.

A 的代码中就需要设计到和 B\C 相关的操作, B\C 的代码中也需要设计和 A 相关的操作.

引入生产者消费者模型后, 就可以降低上述的耦合.

这样 如果 B C 挂了, 对 A 的影响是微乎其微的.

2. 削峰填谷

这里的峰 和 谷都不是长时间持续的, 而是短时间出现的.

如果外界请求突然暴增, 那么应用服务器大大概率会挂.

如果加入阻塞队列, 就能很好避免这种情况. 即使外界的请求出现峰值, 也是由队列来承担峰值请求.

Java标准库里提供了现成的阻塞队列数据结构.

阻塞队列的方法描述:

阻塞队列并没有提供带有阻塞功能的获取队头元素的方法.

2. 基于数组实现阻塞队列

1. 先实现普通队列

class MyBlockingQueue {
    private String[] elems = null;
    public MyBlockingQueue(int capacity) {
        elems = new String[capacity];
    }

    private int head = 0;
    private int tail = 0;
    private int size = 0;
    //入队列
    public void put(String elem) {
        if(size >= elems.length) {
            //队列满了
            return;
        }
        elems[tail] = elem;
        tail++;
        if(tail >= elems.length){
            tail = 0;
            //也可以写成
            //tail = tail % elems.length;
        }
        size++;

    }
    //出队列
    public  String take() {
        if(size == 0){
            //队列空了
            //后续需要让这个代码阻塞
            return null;
        }
        //去除 head 位置的元素并返回
        String elem = elems[head];
        head++;
        if(head >= elems.length) {
            head = 0;
        }
        size--;
        return elem;
    }
}

2. 再加上线程安全

那第一个 if 是否也要加锁? 

如果不加锁会发生什么

所以 put 方法的加锁应该包括第一个 if

    public void put(String elem) {
        synchronized(locker) {
            if(size >= elems.length) {
                //队列满了
                return;
            }
            elems[tail] = elem;
            tail++;
            if(tail >= elems.length){
                tail = 0;
            }
            size++;
        }
    }

对于 take 方法加锁也是一样的. 

3. 再实现阻塞功能

如果队列满还想入队, 就要实现阻塞功能.

队列不满就可以唤醒了. (出队列成功就是队列不满)

对于满了的入队阻塞, 要在出队列成功后唤醒. 而对于空了的出队阻塞, 要在入队成功后唤醒.

但是 入队列操作的唤醒 还有可能唤醒其他等待入队列的操作:

解决这个问题也很简单:

一旦程序进入阻塞, 再被唤醒, 这中间就有很多变数了, 所以很难保证 你的条件是否还满足入队列的条件.

if 只执行了一次判断, 改成 while 之后, 说明 wait 唤醒之后要再次执行判断. 

3. 实现生产者消费者模型

基于上述实现的阻塞队列就可以写一个简单的生产者消费者模型了:

public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue queue = new MyBlockingQueue(100);
        Thread t1 = new Thread(()->{
           int n = 1;
           while(true) {
               try {
                   queue.put(n + "");
                   System.out.println("生产者:" + n);
                   Thread.sleep(500);
                   n++;
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        Thread t2 = new Thread(()->{
            while(true) {
                try {
                    String n = queue.take();
                    System.out.println("消费者:" + n);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        t2.start();
    }

实际开发中, 生产者消费者模型, 往往是多个生产者, 多个消费者.

这里的生产者和消费者不仅仅是一个线程, 也可能是一个独立的服务器程序, 甚至是一组服务器程序. 

看到这里, 你明白了吗?