阻塞队列产生前景：在实际应用场景中，多生产者、多消费者模式，如果我们自己构造一个FIFO先进先出队列，在多线程从队列存取数据的时候，需要操作一些临界资源，我们不仅要考虑加锁的情况，还要考虑队列是否满了，满了就要wait直到队列不满的时候再往里面存，并且唤醒notify取元素线程，相反，队列空了就wait直到队列不空的时候再从里面取，唤醒notify存元素线程；一但操作不当，容易造成阻塞唤醒问题，容易引起死锁；所以Concurrent包的作者为我们编写了各种阻塞队列；
下面将要介绍的是阻塞队列之一的ArrayBlockingQueue：
目录
1、ArrayBlockingQueue简介
ArrayBlockingQueue是属于一种FIFO先进先出阻塞队列，一个底层由数组结构组成的有界阻塞队列；为什么叫阻塞队列（BlockingQueue）？比普通队列多了两个阻塞操作的方法，即阻塞的插入和阻塞移除：
（1）、支持阻塞的插入方法put()：添加元素时，当阻塞队列元素已满时（前提是有界队列），该线程不会抛出异常，线程阻塞，等到元素不满时才重新唤醒线程执行元素加入操作；
（2）、支持阻塞的移除方法take()：删除时，在队列元素为空时，删除队列元素的线程不会抛出异常，将被阻塞，等到队列有元素时再执行删除操作；
2、ArrayBlockingQueue结构
我们要讲解的ArrayBlockingQueue结构如下图，在IDEA工具中，先找到类源码，使用Ctrl+Shift+Alt+U 快捷键，即可看到源码的结构图
3、类中的变量和构造方法
基本结构：
类中的属性：
/**
* Serialization ID. 用于序列化
*/
private static final long serialVersionUID = -817911632652898426L;
/** 存放的元素，说明底层是数组结构 */
final Object[] items;
/**元素的取出索引，用于下一次调用如下方法时使用：
take, poll, peek or remove ；
队列中没有存整个数组的下标索引*/
int takeIndex;
/** 元素的添加索引，用于下一次调用如下方法时使用：
put, offer, or add ；
队列中没有存整个数组的下标索引*/
int putIndex;
/** 队列中元素个数 */
int count;
/** 主要的锁，用来保护所有的访问*/
final ReentrantLock lock;
/** 等待获取条件Condition for waiting takes */
private final Condition notEmpty;
/**等待存放条件 Condition for waiting puts */
private final Condition notFull;
/**
迭代器
*/
transient Itrs itrs = null;
构造方法如下：
/**默认构造方法 */
public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}
/**各项初始化工作，默认是非公平阻塞队列；
公平与非公平，底层是使用Reentrantlock的公平与非公平锁来实现；
所以非公平方式，效率更高一些，在前面分析Reentrantlock有提到；
什么是公平队列，被阻塞的线程可以按照阻塞的先后顺序访问队列，
即先阻塞的线程先访问队列。而非公平队列，当队列可用时，阻塞
的线程将进入争夺访问资源的竞争中，也就是说谁先抢到谁就执行，
没有固定的先后顺序；*/
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();
}
4、插入元素方法
（1）非阻塞方法add（调用offer）
添加失败抛出IllegalStateException异常
public boolean add(E e) {
//调用父类的add方法
return super.add(e);
}
//父类AbstractQueue中的add方法
public boolean add(E e) {
//如果添加成功，返回true，否则抛出IllegalStateException
//这时调用的是子类ArrayBlockingQueue中的offer方法
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
//子类ArrayBlockingQueue中的offer方法
public boolean offer(E e) {
//检查是否为空
checkNotNull(e);
final ReentrantLock lock = this.lock;
//获取锁
lock.lock();
try {
//如果队列满了，那么返回false，添加失败；
//到父类中的add方法，false就会抛出IllegalStateException
if (count == items.length)
return false;
else {
enqueue(e);
return true;
}
} finally {
//在finally块中释放锁
lock.unlock();
}
}
/** 内部私有方法*/
private void enqueue(E x) {
// assert lock.getHoldCount() == 1;
// assert items[putIndex] == null;
final Object[] items = this.items;
items[putIndex] = x;
//如果数组元素满了以后，会重置存放索引为0
//为什么会重置为0，因为队列满了以后，
//再次添加元素的时候，会从队列头部开始，
//如果满队列此时没有元素出队，添加元素要么失败抛出异常，
//要么阻塞
if (++putIndex == items.length)
putIndex = 0;
count++;
//唤醒在等待获取元素的线程
notEmpty.signal();
}//此外还有带超时的offer方法，
//规定时间内添加元素，否则超时抛出异常
public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException
（2）阻塞方法put，存放元素
/** put函数用于存放元素，在当前线程被中断时会抛出异常/
public void put(E e) throws InterruptedException {
//检查是否为空
checkNotNull(e);
final ReentrantLock lock = this.lock;
//获取，可中断锁，如果未被中断，则线程持有锁
lock.lockInterruptibly();
try {
//如果元素满了，则采用condition等待，
//notFull添加元素条件进行等待；
while (count == items.length)
notFull.await();
//否则正常添加
enqueue(e);
} finally {
//在finally块中释放锁
lock.unlock();
}
}
5、删除元素方法
（1）、非阻塞poll方法，移除头元素
获取并移除此队列的头元素，若队列为空，则返回 null
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
//如果队列为空，返回null
//否则调用dequeue方法获取元素
return (count == 0) ? null : dequeue();
} finally {
lock.unlock();
}
}
private E dequeue() {
// assert lock.getHoldCount() == 1;
// assert items[takeIndex] != null;
final Object[] items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];
//因为需要取出这个元素，所以置空该获取索引
items[takeIndex] = null;
//元素空了以后，重置获取索引为0；
//原理跟上面putIndex重置为0一样
if (++takeIndex == items.length)
takeIndex = 0;
count--;
if (itrs != null)
//当数组元素为空，或者获取下标重置0时候，需要更新迭代器
itrs.elementDequeued();
notFull.signal();
//返回被删除的元素
return x;
}//此外还有带超时的poll方法，
//规定时间内移除返回元素，否则超时抛出异常
public E poll(long timeout, TimeUnit unit) throws InterruptedException
（2）、非阻塞remove方法，移除指定元素
public boolean remove(Object o) {
if (o == null) return false;
final Object[] items = this.items;
final ReentrantLock lock = this.lock;
lock.lock();
try {
if (count > 0) {
final int putIndex = this.putIndex;
//获取下标
int i = takeIndex;
do {
//循环，一直找到要删除的元素
if (o.equals(items[i])) {
removeAt(i);
return true;
}
if (++i == items.length)
i = 0;
} while (i != putIndex);
}
return false;
} finally {
lock.unlock();
}
}
void removeAt(final int removeIndex) {
// assert lock.getHoldCount() == 1;
// assert items[removeIndex] != null;
// assert removeIndex >= 0 && removeIndex < items.length;
final Object[] items = this.items;
if (removeIndex == takeIndex) {
// removing front item; just advance
items[takeIndex] = null;
//元素空了以后，重置获取下标索引
if (++takeIndex == items.length)
takeIndex = 0;
count--;
if (itrs != null)
itrs.elementDequeued();
} else {
// an "interior" remove
// slide over all others up through putIndex.
final int putIndex = this.putIndex;
for (int i = removeIndex;;) {
int next = i + 1;
if (next == items.length)
next = 0;
if (next != putIndex) {
items[i] = items[next];
i = next;
} else {
items[i] = null;
this.putIndex = i;
break;
}
}
count--;
if (itrs != null)
itrs.removedAt(removeIndex);
}
//唤醒等待添加的阻塞队列
notFull.signal();
}（3）、阻塞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() {
// assert lock.getHoldCount() == 1;
// assert items[takeIndex] != null;
final Object[] items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];
items[takeIndex] = null;
if (++takeIndex == items.length)
takeIndex = 0;
count--;
if (itrs != null)
itrs.elementDequeued();
notFull.signal();
return x;
}这里有一个小tip就是：take和put方法，都是阻塞的，都带字母t，我们可以这样去记；
6、返回队列头元素方法peek（不删除）
（1）、直接返回头元素，但是并不删除头元素
public E peek() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return itemAt(takeIndex); // null when queue is empty
} finally {
lock.unlock();
}
}7、其他方法，不一一分析
//返回数组队列大小
public int size()
//查找是否包含元素
public boolean contains(Object o)
//迭代队列数组
public Iterator<E> iterator() {
return new Itr();
}以上是整个阻塞队列ArrayBlockingQueue的分析，不是很难，比起看ConcurrentHashMap、AQS之类的源码简单多了，花了一点时间分析一下。
下一篇：
4909
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
