快速掌握并发编程---ArrayBlockingQueue 底层原理和实战
背景
在JDK1.5的时候，在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。
本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。分析ArrayBlockingQueue的底层源码分析。
BlockingQueue 简介
阻塞队列，顾名思义，首先它是一个队列，而一个队列在数据结构中所起的作用大致如下图所示：
从上图我们可以很清楚看到，通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出。
常用的队列主要有以下两种：（当然通过不同的实现方式，还可以延伸出很多不同类型的队列，DelayQueue就是其中的一种）
先进先出（FIFO）：先插入的队列的元素也最先出队列，类似于排队的功能。从某种程度上来说这种队列也体现了一种公平性。
后进先出（LIFO）：后插入队列的元素最先出队列，这种队列优先处理最近发生的事件。
下面两幅图演示了BlockingQueue的两个常见阻塞场景：
如上图所示：当队列中没有数据的情况下，消费者端的所有线程都会被自动阻塞（挂起），直到有数据放入队列。
如上图所示：当队列中填满数据的情况下，生产者端的所有线程都会被自动阻塞（挂起），直到队列中有空的位置，线程被自动唤醒。
这也是我们在多线程环境下，为什么需要BlockingQueue的原因。作为BlockingQueue的使用者，我们再也不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue都给你一手包办了。
既然BlockingQueue如此神通广大，让我们一起来见识下它的常用方法：
BlockingQueue的核心方法
添加数据：
offer(anObject)：表示如果可能的话，将anObject加到BlockingQueue里，即如果BlockingQueue可以容纳，则返回true，否则返回false。（本方法不阻塞当前执行方法的线程）
offer(E o, long timeout, TimeUnit unit)：可以设定等待的时间，如果在指定的时间内，还不能往队列中加入BlockingQueue，则返回失败。
put(anObject)：把anObject加到BlockingQueue里，如果BlockingQueue没有空间,则调用此方法的线程被阻断，直到BlockingQueue里面有空间再继续。
获取数据：
poll(time)：取走BlockingQueue里排在首位的对象,若不能立即取出，则可以等time参数规定的时间，取不到时返回null。
poll(long timeout, TimeUnit unit)：从BlockingQueue取出一个队首的对象，如果在指定时间内，队列一旦有数据可取，则立即返回队列中的数据。否则知道时间超时还没有数据可取，返回失败。
take()：取走BlockingQueue里排在首位的对象，若BlockingQueue为空，阻断进入等待状态直到BlockingQueue有新的数据被加入。
drainTo()：一次性从BlockingQueue获取所有可用的数据对象（还可以指定获取数据的个数）， 通过该方法，可以提升获取数据效率；不需要多次分批加锁或释放锁。
常见BlockingQueue
在了解了BlockingQueue的基本功能后，让我们来看看BlockingQueue家庭大致有哪些成员？
ArrayBlockingQueue源码分析
构造方法
在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];
//这里用的就是重入锁，
//公平性通过fair来判断
lock = new ReentrantLock(fair);
//不为空条件队列，明显就是给消费者用
notEmpty = lock.newCondition();
//没有满条件队列，给生产者用
notFull = lock.newCondition();
}
重要属性
//底层数据结构，说明底层存储数据的数据结构是数组
private final E[] items;
//用来为下一个take/poll/remove的索引（出队）
private int takeIndex;
//用来为下一个put/offer/add的索引（入队）
private int putIndex;
//队列中元素的个数
private int count;
/** Main lock guarding all access */
private final ReentrantLock lock;//锁
/** Condition for waiting takes */
private final Condition notEmpty;//等待出队的条件
/** Condition for waiting puts */
private final Condition notFull;//等待入队的条件
从这几个属性就能看出来，ArrayBlockingQueue的底层组成为：
数组
一个重入锁
两个条件队列
入队
add()方法
public boolean add(E e) {
// 调用父类的add(e)方法
return super.add(e);
}
public boolean add(E e) {
// 调用offer(e)如果成功返回true，如果失败抛出异常
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
offer(e)方法入队
入参e为null，会抛空指针异常
元素插入到队尾（putIndex自增）
唤醒线程
生产者消费者模式
/**
* 在队尾插入一个元素，
* 如果队列没满，立即返回true；
* 如果队列满了，立即返回false
* 注意：该方法通常优于add(),因为add()失败直接抛异常
*/
public boolean offer(E e) {
//检查存入的数据是否为null
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lock();
try {
//如果数组满了，返回入队失败
if (count == items.length)
return false;
else {
//入队
enqueue(e);
return true;
}
} finally {
lock.unlock();
}
}
//如果存入的数据是null的会抛控指针异常
private static void checkNotNull(Object v) {
if (v == null) throw new NullPointerException();
}
//putIndex是int类型，默认值就是0
private void enqueue(E x) {
final Object[] items = this.items;
//从下标为0的位置开始放入数据
items[putIndex] = x;
//如果putIndex等于数组大小，证明这是最后一个能存放的，然后把putIndex设置为0
//否则++putIndex
if (++putIndex == items.length){
putIndex = 0;
}
//放入数据个数+1
count++;
/**
* 唤醒一个线程
* 如果有任意一个线程正在等待这个条件，那么选中其中的一个区唤醒。
* 在从等待状态被唤醒之前，被选中的线程必须重新获得锁
*/
notEmpty.signal();
}
带超时时间的offer，在队尾插入一个元素,，如果数组已满，则进入等待，直到出现以下三种情况：-->阻塞
被唤醒
等待时间超时
当前线程被中断
put方法入队
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
//加锁，如果线程中断了抛出异常
lock.lockInterruptibly();
try {
while (count == items.length){
//这里就是阻塞了，要注意。如果运行到这里，
//那么它会释放上面的锁，一直等到唤醒
notFull.await();
}
//放入队列
enqueue(e);
} finally {
lock.unlock();
}
}
小结
add(e)时如果队列满了则抛出异常；
offer(e)时如果队列满了则返回false；
put(e)时如果队列满了则使用notFull等待；
offer(e, timeout, unit)时如果队列满了则等待一段时间后如果队列依然满就返回false；
enqueue()利用放指针循环使用数组来存储元素；
出队
take方法出队
从头部出队
队中没有数据，等待被唤醒再取数据。
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
//加锁，如果线程中断了抛出异常
lock.lockInterruptibly();
try {
//队列中不存元素
while (count == 0){
/*
* 一直等待条件notEmpty，即被其他线程唤醒
* （唤醒其实就是，有线程将一个元素入队了，然后调用notEmpty.signal()
* 唤醒其他等待这个条件的线程，同时队列也不空了）
*/
notEmpty.await();
}
//否则出队
return dequeue();
} finally {
lock.unlock();
}
}
private E dequeue() {
final Object[] items = this.items;
// 取取指针位置的元素
E x = (E) items[takeIndex];
// 把取指针位置设为null
items[takeIndex] = null;
// 取指针前移，如果数组到头了就返回数组前端循环利用
if (++takeIndex == items.length)
takeIndex = 0;
// 元素数量减1
count--;
if (itrs != null)
itrs.elementDequeued();
// 唤醒notFull条件
notFull.signal();
return x;
}
poll方法出队
太简单了，如果队列里没有数据，就直接返回null，否则从队列头部出队
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
//如果队列里没有数据就直接返回null
//否则从队列头部出队
return (count == 0) ? null : dequeue();
} finally {
lock.unlock();
}
}
remove方法
public E remove() {
// 调用poll()方法出队
E x = poll();
if (x != null)
// 如果有元素出队就返回这个元素
return x;
else
// 如果没有元素出队就抛出异常
throw new NoSuchElementException();
}
小结
remove()时如果队列为空则抛出异常；
poll()时如果队列为空则返回null；
take()时如果队列为空则阻塞等待在条件notEmpty上；
poll(timeout, unit)时如果队列为空则阻塞等待一段时间后如果还为空就返回null；
dequeue()利用取指针循环从数组中取元素；
总结
1.ArrayBlockingQueue不需要扩容，因为是初始化时指定容量，并循环利用数组；
2.ArrayBlockingQueue利用takeIndex和putIndex循环利用数组；
3.入队和出队各定义了四组方法为满足不同的用途；
4.利用重入锁和两个条件保证并发安全。