1类签名与简介
public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable
一个有限的阻塞队列由数组支持。 这个队列排列元素FIFO(先进先出)。新元素插入队列的尾部,队列检索操作获取队列头部的元素。
ArrayBlockingQueue是线程安全的,其内部通过“互斥锁”(Lock)保护竞争资源,实现了多线程对竞争资源的互斥访问。
ArrayBlockingQueue的容量是固定的,确定之后无法更改。该实现既包含了一组非阻塞的操作的API,也包括了一组阻塞操作的API。
阻塞情况有如下两种:(1)当队列为null时,取操作会阻塞;(2)当队列为满时,插入操作会被阻塞。
ArrayBlockingQueue是并发包中的类,可以用来实现经典的“生产者/消费者”模型。
2重要属性
//items数组存储队列中的元素 final Object[] items; //下一个取元素的索引(take, poll, peek or remove ) int takeIndex; //下一个插入元素应该的索引(put, offer, or add) int putIndex; //队列中元素的个数 int count; /** Main lock guarding all access */ final ReentrantLock lock; /** Condition for waiting takes */ private final Condition notEmpty; /** Condition for waiting puts */ private final Condition notFull;
takeIndex表示下一个待取元素的索引,对于队列来说就是队头,相应的putIndex指向队尾。lock是ArrayBlockingQueue类的主锁,该类的主要方法都要加上此锁。
notEmpty和notFull实现了队列的阻塞,当为队列为null时,再取元素就会调用notEmpty.await()进入阻塞状态,当入队时肯定不为空,就会调用notEmpty.signal()唤醒阻塞的线程继续执行。同理notFull就不多介绍,对Lock锁与Condition 不熟悉的多线程基本知识了解一下。
3 基本操作(入队/出队)
(1)入队enqueue
private void enqueue(E x) { // assert lock.getHoldCount() == 1; // assert items[putIndex] == null; final Object[] items = this.items; items[putIndex] = x; if (++putIndex == items.length) putIndex = 0; count++; notEmpty.signal(); }
首先,在队尾也就是putIndex指向的位置插入新元素;然后,putIndex增1,若此时putIndex等于items.length(超过了数组的最后一位items.length-1),putIndex循环到数组的第一位。同理面的takeIndex也有次操作,所以该队列是由循环数组实现的,每次插入队尾后移1位,每次取出队头向后移1位。图就不画,自行脑补。然后计数count++;最后随机唤醒1个由notEmpty.await阻塞的线程(若有的话),因为有元素入队了,此时队列肯定不为null了。
(2)出队dequeue
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; }
删除队头元素。
4常用方法
(1)添加/入队(add、offer、put)
add方法如下
public boolean add(E e) { return super.add(e); } //父类AbstractQueue中的add public boolean add(E e) { if (offer(e)) return true; else throw new IllegalStateException("Queue full"); }
ArrayBlockingQueue的add调用了父类AbstractQueue的add,add方法调用offer方法进行插入,offer返回true则add成功,offer返回false也就是插入失败会抛出异常。ArrayBlockingQueue实现了自己的offer,所以此处虽然调用父类的add,但是继承过来的add会调用自己的offer(多态)。
offer代码如下
public boolean offer(E e) { checkNotNull(e); final ReentrantLock lock = this.lock; lock.lock(); try { if (count == items.length) return false; else { enqueue(e); return true; } } finally { lock.unlock(); } }
这里offer调用enqueue进行入队操作,当队列为满时不会阻塞,而是直接返回false。所以与add相比,offer一个明显的不同是,插入失败时不会报异常。但是add与这里的offer都不是阻塞方法。offer也提供了一个阻塞的重载版本
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) { if (nanos <= 0) return false; nanos = notFull.awaitNanos(nanos); } enqueue(e); return true; } finally { lock.unlock(); } }
队列若满,则线程会阻塞timeout长的时间,超时唤醒后会继续判断队列是否为满。还有一个添加的阻塞方法就是put,对于阻塞似乎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(); } }
与上面的offer类似,不同的是没有阻塞时间,需要被notFull Condition来唤醒。
(2)删除/出队(poll、take)
poll方法如下
public E poll() { final ReentrantLock lock = this.lock; lock.lock(); try { return (count == 0) ? null : dequeue(); } finally { lock.unlock(); } }
这里的poll提供了一个非阻塞的出队操作。当队列为空时,返回null,否则出队并返回出队的元素。
当然,与offer类似,poll还有一个阻塞的重载版本。
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; nanos = notEmpty.awaitNanos(nanos); } return dequeue(); } finally { lock.unlock(); } }
ArrayBlockingQueue还提供了一个专门的出队阻塞方法take
public E take() throws InterruptedException { final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { while (count == 0) notEmpty.await(); return dequeue(); } finally { lock.unlock(); } }
当队列为null时,调用 notEmpty.await()使当前线程进入阻塞状态。下一次入队时会有notEmpty.signal()唤醒阻塞线程,这个唤醒只能唤醒一个,而且是随机的。
(3)查看队头元素peek
public E peek() { final ReentrantLock lock = this.lock; lock.lock(); try { return itemAt(takeIndex); // null when queue is empty } finally { lock.unlock(); } }
返回队头元素,不删除。
(4)其他
由于ArrayBlockingQueue是由数组实现的,除了出队(删除队头元素),当然也可以删除任意位置的元素,所以此类对于删除操作还提供了如下方法
remove(Object o) //查找队列,若存在元素o则删除 removeAt(final int removeIndex) //删除指定位置的元素
ArrayBlockingQueue重写了toString方法,将队列中所有元素用[]括起来,然后元素之间用逗号加空格分开。详细自行阅读源码。
drainTo
//将队列中的所有元素放到集合c中 public int drainTo(Collection<? super E> c) { return drainTo(c, Integer.MAX_VALUE); } //将队列中的所有元素放到集合c中 public int drainTo(Collection<? super E> c, int maxElements) { checkNotNull(c); if (c == this) throw new IllegalArgumentException(); if (maxElements <= 0) return 0; final Object[] items = this.items; final ReentrantLock lock = this.lock; lock.lock(); try { int n = Math.min(maxElements, count); int take = takeIndex; int i = 0; try { while (i < n) { @SuppressWarnings("unchecked") E x = (E) items[take]; c.add(x); items[take] = null; if (++take == items.length) take = 0; i++; } return n; } finally { // Restore invariants even if c.add() threw if (i > 0) { count -= i; takeIndex = take; if (itrs != null) { if (count == 0) itrs.queueIsEmpty(); else if (i > take) itrs.takeIndexWrapped(); } for (; i > 0 && lock.hasWaiters(notFull); i--) notFull.signal(); } } } finally { lock.unlock(); } }
完