一篇文章彻底搞懂BlockingQueue之ArrayBlockingQueue阻塞队列（深度剖析）

---

前言

---

一、了解什么是阻塞队列之前，需要先知道队列

Queue接口（队列）

定义了队列的基本功能，添加、删除、查询。
满足FIFO(先进先出原则）。

public interface Queue<E> extends Collection<E> {
    //添加一个元素，添加成功返回true, 如果队列满了，就会抛出异常
    boolean add(E e);
    //添加一个元素，添加成功返回true, 如果队列满了，返回false
    boolean offer(E e);
    //返回并删除队首元素，队列为空则抛出异常
    E remove();
    //返回并删除队首元素，队列为空则返回null
    E poll();
    //返回队首元素，但不移除，队列为空则抛出异常
    E element();
    //获取队首元素，但不移除，队列为空则返回null
    E peek();
}

---

二、BlockingQueue接口（阻塞队列）

BlockingQueue，是java.util.concurrent 包提供的用于解决并发生产者 - 消费者问题的最有用的类，它的特性是在任意时刻只有一个线程可以进行take或者put操作，并且BlockingQueue提供了超时return null的机制，在许多生产场景里都可以看到这个enq工具的身影。

可以看到他是继承于JDK的Queue。

2.1、阻塞队列特性

1、队列类型
无限队列 （unbounded queue ） - 几乎可以无限增长
有限队列 （ bounded queue ） - 定义了最大容量

2、队列数据结构
队列实质就是一种存储数据的结构，通常用链表或者数组实现。
一般而言队列具备FIFO先进先出的特性，当然也有双端队列（Deque）优先级队列
主要操作：入队（EnQueue）与出队（Dequeue）

---

2.2、核心功能

入队：
1、offer(E e)：如果队列没满，返回true，如果队列已满，返回false（不阻塞）
2、offer(E e, long timeout, TimeUnit unit)：可以设置阻塞时间，如果队列已满，则进行阻塞。超过阻塞时间，则返回false
3、put(E e)：队列没满的时候是正常的插入，如果队列已满，则阻塞，直至队列空出位置。

---

出队：
1、poll()：如果有数据，出队，如果没有数据，返回null （不阻塞）
2、poll(long timeout, TimeUnit unit)：可以设置阻塞时间，如果没有数据，则阻塞，超过阻塞时间，则返回null
3、peek()：获取队首元素，但不移除，队列为空则返回null
4、take()：队列里有数据会正常取出数据并删除；但是如果队列里无数据，则阻塞，直到队列
里有数据。

---

常用API总结
当队列满了无法添加元素，或者是队列空了无法移除元素时：
抛出异常：add、remove、element
返回结果但不抛出异常：offer、poll、peek
阻塞：put、take

---

2.3、常见的4种阻塞队列

ArrayBlockingQueue：由数组支持的有界队列
LinkedBlockingQueue：由链接节点支持的可选有界队列
PriorityBlockingQueue ：由优先级堆支持的无界优先级队列
DelayQueue ：由优先级堆支持的、基于时间的调度队列

---

三、ArrayBlockingQueue-源码分析

PS：先看个关系图

ArrayBlockingQueue是最典型的有界阻塞队列，其内部是用数组存储元素的，初始化时需要指定容量大小，利用 ReentrantLock 实现线程安全。
在生产者-消费者模型中使用时，如果生产速度和消费速度基本匹配的情况下，使用ArrayBlockingQueue是个不错选择；
当如果生产速度远远大于消费速度，则会导致队列填满，大量生产线程被阻塞。
使用独占锁ReentrantLock实现线程安全，入队和出队操作使用同一个锁对象，也就是只能有一个线程可以进行入队或者出队操作；
这也就意味着生产者和消费者无法并行操作，在高并发场景下会成为性能瓶颈。

PS：从图中可以看有2个指针，插入和获取。

ArrayBlockingQueue使用

BlockingQueue<String> queue = new ArrayBlockingQueue(1024);
        queue.put("1");   //向队列中添加元素
        String take = queue.take(); // 获取元素

---

ArrayBlockingQueue特性

---

3.1、ArrayBlockingQueue-构造方法

 public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }

    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

参数：
capacity:定义数组大小
fair：true/false（公平、非公平锁）
默认是非公平锁的实现

---

3.2、ArrayBlockingQueue-核心属性

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {

    /** The queued items */
    final Object[] items;

    /** items index for next take, poll, peek or remove */
    int takeIndex;

    /** items index for next put, offer, or add */
    int putIndex;

    /** Number of elements in the queue */
    int count;

    /*
     * Concurrency control uses the classic two-condition algorithm
     * found in any textbook.
     */

    /** Main lock guarding all access */
    final ReentrantLock lock;

    /** Condition for waiting takes */
    private final Condition notEmpty;

    /** Condition for waiting puts */
    private final Condition notFull;
}

属性说明
items：存放元素的数组。
takeIndex：获取的指针位置。
putIndex：插入的指针位置。
count：队列中的元素个数。
lock：内部锁。
notEmpty：消费者
notFull：生产者

---

3.3、put-入队方法

public void put(E e) throws InterruptedException {
	//检查是否为空
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    //加锁，如果线程中断抛出异常 
    lock.lockInterruptibly();
    try {
       //阻塞队列已满，则将生产者挂起，等待消费者唤醒
       //设计注意点： 用while不用if是为了防止虚假唤醒
        while (count == items.length)
            notFull.await(); //队列满了，使用notFull等待（生产者阻塞）
        // 入队
        enqueue(e);
    } finally {
        lock.unlock(); // 唤醒消费者线程
    }
}
    
private void enqueue(E x) {
    final Object[] items = this.items;
    //入队   使用的putIndex
    items[putIndex] = x;
    if (++putIndex == items.length) 
        putIndex = 0;  //设计的精髓： 环形数组，putIndex指针到数组尽头了，返回头部
    count++;
    //notEmpty条件队列转同步队列，准备唤醒消费者线程，因为入队了一个元素，肯定不为空了
    notEmpty.signal();
}

put主要做了几件事情
1、加中断锁lockInterruptibly（和普通lock一样，只不过多了个判断，如果被中断，则抛异常）。
2、判断队列中的数组长度元素已满，满了则让生产者阻塞。
3、没满，则入队，调用enqueue方法
4、解锁

enqueue主要做了几件事情
1、入队时，把元素放在当前putIndex指针的位置上。
2、看下一指针位置是不是到了队尾，如果是，则改为0（设计的精髓： 环形数组，putIndex指针到数组尽头了，返回头部）。
3、数组元素+1
4、唤醒消费者线程，因为入队了一个元素，肯定不为空了。

---

3.4、take出队方法

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    //加锁，如果线程中断抛出异常 
    lock.lockInterruptibly();
    try {
       //如果队列为空，则消费者挂起
        while (count == 0)
            notEmpty.await();
        //出队
        return dequeue();
    } finally {
        lock.unlock();// 唤醒生产者线程
    }
}
private E dequeue() {
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex]; //取出takeIndex位置的元素
    items[takeIndex] = null;
    if (++takeIndex == items.length)
        takeIndex = 0; //设计的精髓： 环形数组，takeIndex 指针到数组尽头了，返回头部
    count--;
    if (itrs != null)
        itrs.elementDequeued();
    //notFull条件队列转同步队列，准备唤醒生产者线程，此时队列有空位
    notFull.signal();
    return x;
}

take主要做了几件事情
1、添加中断锁。
2、判断队列是否为空，为空，消费者则挂起
3、如果不为空，则出队，调用dequeue方法
4、解锁

dequeue主要做了几件事情
1、取出takeIndex指针位置的元素。
2、看指针位置是不是到了队尾，如果是，则置0，下一次从头在拿。
3、唤醒生产者线程，此时队列有空位

---

总结

ArrayBlockingQueue 是一个环形数组，通过维护队首、队尾的指针，来优化（避免了数组的插入和删除，带来的数组位置移动）插入、删除，从而使时间复杂度为O(1).