JUC源码分析17-队列-ArrayBlockingQueue

看ArrayBlockingQueue的javadoc说明，简单翻译过来：

1.基于数组实现的有界阻塞队列，队列采用FIFO；

2.因为基于数组，所以队列创建后大小不能改变。线程在插入元素到一个满的队列时会阻塞，线程获取元素时，队列为空也会阻塞；

3.对于队列的生产和消费线程提供了公平非公平策略。

ArrayBlockingQueue继承AbstractQueue抽象类，实现了BlockingQueue接口，BlockingQueue接口也在juc包，看下先：

public interface BlockingQueue<E> extends Queue<E> {
/**
* 插入元素到队列，成功就true，失败就IllegalStateException异常
*/
boolean add(E e);

/**
* 跟add一样，插入元素到队列，成功就true，不过失败的时候是false，不是异常
*/
boolean offer(E e);

/**
* 插入元素到队列，跟上面2个的区别是add跟offer如果插入的时候队列full就直接返回false，而put会加入到条件队列
*/
void put(E e) throws InterruptedException;

/**
* 插入元素到队列，如果队列full，就等待timeout时间，还不行就返回false
*/
boolean offer(E e, long timeout, TimeUnit unit)
throws InterruptedException;

/**
* 获取元素，队列空的时候会等待
*/
E take() throws InterruptedException;

/**
* 获取元素，队列空的时候会等待timeout时间
*/
E poll(long timeout, TimeUnit unit)
throws InterruptedException;

/**
* 获取剩余容量，不能通过检查这个方法判断插入操作是否成功，因为可能有别的线程插入或删除元素
*/
int remainingCapacity();

boolean remove(Object o);

public boolean contains(Object o);

/**
* 从队列移除元素，添加到新的
*/
int drainTo(Collection<? super E> c);

/**
* 移除指定大小的元素，添加到新的
int drainTo(Collection<? super E> c, int maxElements);
}

看下ArrayBlockingQueue的结构：
//数组存储队列元素
final Object[] items;

/** 队列获取位置 for next take, poll, peek or remove */
int takeIndex;

/** 队列存储位置 for next put, offer, or add */
int putIndex;

/** 队列元素个数 */
int count;

/*
* 利用可重入锁ReentrantLock控制并发
*/
/** Main lock guarding all access */
final ReentrantLock lock;
/** 条件队列控制获取 */
private final Condition notEmpty;
/** 条件队列控制put */
private final Condition notFull;

/**
*初始化，传入队列大小和重入锁的公平策略，默认非公平
*/
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();
}

这里可以看到ArrayBlockingQueue是基于数组实现的有界队列，利用可重入锁ReentrantLock控制并发，然后lock的2个条件队列分别用于获取时队列为空时等待，存储时队列full时等待。
看下几个重要方法：

add和offer：

//add操作和offer的区别就在于插入的时候队列full是返回异常还是false
public boolean add(E e) {
return super.add(e);
}
调用AbstractQueue中的：
public boolean add(E e) {
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
回到ArrayBlockingQueue的offer
public boolean offer(E e) {
checkNotNull(e); //单独提出一个方法判null
final ReentrantLock lock = this.lock;
lock.lock(); //获取锁
try {
if (count == items.length) //队列满时返回false
return false;
else {
insert(e); //队列不满就插入元素，返回true
return true;
}
} finally {
lock.unlock(); //释放条件锁
}
}
//响应超时时间的存储
public boolean offer(E e, long timeout, TimeUnit unit)
throws InterruptedException {

checkNotNull(e);
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly(); //响应中断
try {
while (count == items.length) { //offer的时候队列full
if (nanos <= 0) //重新唤醒后检查超时，小于0就返回false，不行就继续条件队列park
return false;
nanos = notFull.awaitNanos(nanos); //加入lock条件队列，底层park指定时间
}
insert(e);
return true;
} finally {
lock.unlock();
}
}
private static void checkNotNull(Object v) {
if (v == null)
throw new NullPointerException();
}
//插入元素
private void insert(E x) {
items[putIndex] = x;
putIndex = inc(putIndex); //新的put位置
++count;
notEmpty.signal(); //这里在插入元素后通知lock的非空条件队列上的线程
}
//使用使用数组
final int inc(int i) {
return (++i == items.length) ? 0 : i;
}

put和take:
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly(); //可中断
try {
while (count == items.length) //存储时队列满，noteFull条件队列等待
notFull.await();
insert(e); //插入元素
} finally {
lock.unlock();
}
}
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly(); //可中断
try {
while (count == 0) //获取时队列空，notEmpty条件队列等待
notEmpty.await();
return extract(); //获取元素
} finally {
lock.unlock();
}
}
private E extract() {
final Object[] items = this.items;
E x = this.<E>cast(items[takeIndex]); //类型转换，单独出来的方法
items[takeIndex] = null;
takeIndex = inc(takeIndex); //改变take位置
--count;
notFull.signal(); //获取元素后，需要通知所有等待插入条件队列线程可以插入元素
return x;
}

put和take操作获取lock的时候都是响应中断的，跟之前的不一样。put操作insert后需要通知条件等待队列notEmpty的线程，让线程可以take。take操作extract获取元素后通知notFull，让线程可以put插入元素。有点绕口，记得有2个条件等待队列跟他们的作用就行，不要纠结名称。
看下poll：

public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return (count == 0) ? null : extract(); //获取锁后，队列不空就返回当前，否则返回null
} finally {
lock.unlock();
}
}

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly(); //可中断
try {
while (count == 0) {
if (nanos <= 0)
return null; //返回null
nanos = notEmpty.awaitNanos(nanos); //获取锁，响应超时的获取
}
return extract();
} finally {
lock.unlock();
}
}

2个poll跟take的区别是take获取时队列空会加入条件队列，而一个poll则返回null，另一个响应超时后返回null，都不会加入条件队列。
其他方法都差不多，看起来还是相对简单的。