CopyOnWriteArraySet
CopyOnWriteArrayList
BlockingQueue
ArrayBlockingQueue
ConcurrentLinkedQueue
BlockingQueue
BlockingQueue是阻塞队列的顶级接口,定义了一系列的API,主要声明了在获取元素时等待队列变为非空,以及在存储元素时等待空间变得可用这两个特点。
BlockingQueue队列不接受 null 元素,试图插入一个 null 元素时,某些实现会抛出 NullPointerException。此外该类的实现是线程安全的,且主要用作生产者-使用者队列。
API如下(摘自JDK文档中的一部分)
方法摘要 | |
---|---|
boolean | add(E e) 将指定的元素插入此队列(如果立即可行且不会违反容量限制),在成功时返回 true,如果当前没有可用的空间,则抛出 IllegalStateException。 |
E | element() 获取,但是不移除此队列的头。 |
boolean | offer(E e) 将指定的元素插入此队列(如果立即可行且不会违反容量限制),当使用有容量限制的队列时,此方法通常要优于 add(E) ,后者可能无法插入元素,而只是抛出一个异常。 |
E | peek() 获取但不移除此队列的头;如果此队列为空,则返回 null。 |
E | poll() 获取并移除此队列的头,如果此队列为空,则返回 null。 |
E | remove() 获取并移除此队列的头。 |
LinkedBlockingQueue
一个链表结构的有界阻塞队列,也可以说无界,因为默认容量为Integer.MAX_VALUE,基本上达不到,其内部维护了一个基于Node链表,只要容量未达到Integer.MAX_VALUE,就可以一直扩展,当然也可以在构造时指定容量。主要特点可归纳如下
- 先进先出,新添加的元素位于尾部,获取操作取出头部元素
- 通过可重入锁ReentrantLock + Condition条件来实现生产—消费模式下的同步控制,保证安全性
- 对于put 与 take,分别提供了各自ReentrantLock,所以put 与 take之间在锁上面不会产生阻塞,而是在条件上面。
- 相较于ArrayBlockingQueue来说,吞吐量通常要高于基于数组的队列
其源码也比较简单,以1.8为例,主要的属性及构造器如下
// 头节点
transient Node<E> head;
// 尾节点
private transient Node<E> last;
/** Lock held by take, poll, etc */
private final ReentrantLock takeLock = new ReentrantLock();
/** Wait queue for waiting takes */
private final Condition notEmpty = takeLock.newCondition();
/** Lock held by put, offer, etc */
private final ReentrantLock putLock = new ReentrantLock();
/** Wait queue for waiting puts */
private final Condition notFull = putLock.newCondition();
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}
public LinkedBlockingQueue(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException();
this.capacity = capacity;
last = head = new Node<E>(null);
}
add(E e) / put(E e) /offer(E e)主要区别
- 队列已满时,offer操作立即返回false,put操作则挂起当前线程,等待队列空间变得可用;
而add(E e)是对offer的包装,当offer返回false后,add抛出一个异常。 - put在获取锁putLock.lockInterruptibly()之前或过程中可以响应中断的,线程被中断的情况下会抛出中断异常,而offer中 putLock.lock();是不响应中断的,会一直等到成功获取锁。
在队列空间足够的情况,都会将元素添加链表尾部,添加后,如果队列仍然未达最大容量,则执行notFull.signal()唤醒一个处于等待中的生产线程(等待队列被消费);如果队列为空,则添加后执行notEmpty.signal()唤醒一个处于等待中的消费线程(等待队列不为空)。
public boolean add(E e) {
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
int c = -1;
Node<E> node = new Node<E>(e);
final ReentrantLock putLock = this.putLock;
final AtomicInteger count = this.count;
putLock.lockInterruptibly();
try {
// 队列已满,则挂起当前线程,等待消费线程消费
while (count.get() == capacity) {
notFull.await();
}
// 否则,将元素添加到队列尾部
enqueue(node);
c = count.getAndIncrement();
// 添加元素后,如果队列仍未满,则唤醒后续生产者,继续添加。
if (c + 1 < capacity)
notFull.signal();
} finally {
putLock.unlock();
}
// 如果队列为空,则添加元素后,执行notEmpty.signal()唤醒一个消费者
if (c == 0)
signalNotEmpty();
}
private void enqueue(Node<E> node) {
// assert putLock.isHeldByCurrentThread();
// assert last.next == null;
last = last.next = node;
}
private void signalNotEmpty() {
final ReentrantLock takeLock = this.takeLock;
takeLock.lock();
try {
notEmpty.signal();
} finally {
takeLock.unlock();
}
}
take()/poll()/peek()的主要区别
- take在队列为空时,会挂起当前线程,直到队列中有可用数据,而poll则立即返回null。
- 同样的take在获取锁 takeLock.lockInterruptibly()之前或过程中,可以响应中断,而poll获取锁的方式takeLock.lock()会直到锁成功获取。
- peek()只获取但不删除此队列的头,如果此队列为空,则返回
null
元素取完之后,如果队列中仍有元素,则唤醒一个处于等待中的消费线程(等待队列有可用数据);如果是在队列满状态的情况下取走一个,则调用notFull.signal()唤醒一个处于等待中的生产线程(等待队列被消费)
public E take() throws InterruptedException {
E x;
int c = -1;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
takeLock.lockInterruptibly();
try {
// 队列为空,则等待
while (count.get() == 0) {
notEmpty.await();
}
// 否则获取并移除头部元素
x = dequeue();
c = count.getAndDecrement();
// 取完之后,如果队列中仍有元素,则唤醒后续其它消费线程
if (c > 1)
notEmpty.signal();
} finally {
takeLock.unlock();
}
// 如果队列满了,则取走一个之后,则调用notFull.signal()唤醒一个生产方
if (c == capacity)
signalNotFull();
return x;
}
private E dequeue() {
// assert takeLock.isHeldByCurrentThread();
// assert head.item == null;
Node<E> h = head;
Node<E> first = h.next;
h.next = h; // help GC
head = first;
E x = first.item;
first.item = null;
return x;
}
private void signalNotFull() {
final ReentrantLock putLock = this.putLock;
putLock.lock();
try {
notFull.signal();
} finally {
putLock.unlock();
}
}
remove():takeLock与putLock同时锁定
public boolean remove(Object o) {
if (o == null) return false;
fullyLock();
try {
for (Node<E> trail = head, p = trail.next;
p != null;
trail = p, p = p.next) {
if (o.equals(p.item)) {
unlink(p, trail);
return true;
}
}
return false;
} finally {
fullyUnlock();
}
}
迭代队列:迭代过程中,同样阻塞所有put和take操作,即putLock和takeLock同时会被占用。
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
private Node<E> current;
private Node<E> lastRet;
private E currentElement;
Itr() {
// take与put同时锁住
fullyLock();
try {
current = head.next;
if (current != null)
currentElement = current.item;
} finally {
fullyUnlock();
}
}
public boolean hasNext() {
return current != null;
}
...
void fullyLock() {
putLock.lock();
takeLock.lock();
}
ArrayBlockingQueue
一个数组结构的有界阻塞队列,底层维护了一个Object[]数组来存储元素,该数组在创建后就不会再增加其容量,数组满了后添加操作会受阻塞,数组为空时提取操作将受阻塞。与LinkedBlockQueue的主要区别在于
- 底层数据结构不一样,该类底层为数组,LinkedBlockQueue底层为链表结构
- ArrayBlockingQueue只包含一个锁,所以添加、获取操作之间会在ReentrantLock锁上产生阻塞;
而LinkedBlockQueue对于添加和获取分别提供了一个ReentrantLock,添加、获取之间不会在ReentrantLock锁上产生竞争,而是在队列已满或为空的情况下,在条件Condition上 产生阻塞;
所以理论上来说LinkedBlockQueue吞吐量一般高于ArrayBlockingQueu这种数组结构。 - ArrayBlockingQueu的锁可设置成公平锁或非公平锁(默认使用非公平锁),给等待中的生产线程或消费线程 分配锁时,如果采用公平锁,则会尽量保证按FIFO顺序调起线程,所以公平锁的情况下通常会降低吞吐量,但也减少了可变性和避免了“不平衡性”。
关于公平锁与非公平锁在以前的博客中有过说明,这里简单再介绍,公平锁更倾向于(但并不保证)优先将锁分配给等待时间最长的线程,对应这里就是先进的先执行(对应FIFO),非公平锁就是锁可用的情况下随机分配,有的线程可能很久都获取不到,而有的线程经常获取。
public class ArrayBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
/** The queued items */
final Object[] items;
/** 该值=提取元素下标+1, 表示下个元素(即头部元素)所处下标 */
int takeIndex;
/** 该值=添加元素的下标+1,表示下个元素存放下标*/
int putIndex;
/** 队列中元素的个数,通过比较该值与items.length来判断是空或已满 */
int count;
// 一个锁+两个条件
final ReentrantLock lock;
private final Condition notEmpty;
private final Condition notFull;
transient Itrs itrs = null;
add(E e) / put(E e) /offer(E e)主要区别
- 队列已满时,offer返回false,而put()会等待直到队列可用,add只是对offer包装,当offer()返回false时,add抛出异常。
- 同LinkedBlockingQueue一样,put在获取锁lock.lockInterruptibly()之前或过程中也可以响应中断的,线程被中断的情况下会抛出中断异常,而offer中 lock.lock();是不响应中断的,会一直等到成功获取锁。
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();
}
}
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();
}
}
take()/poll()/peek()
- 队列为空时,take挂起当前线程,直到队列中有可用数据;poll/peek都返回null。
- 同样的take在获取锁 lock.lockInterruptibly()之前或过程中,可以响应中断,而poll获取锁的方式lock.lock()会直到锁成功获取。
- peek()只获取但不删除此队列的头,如果此队列为空,则返回
null
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return dequeue();
} finally {
lock.unlock();
}
}
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return (count == 0) ? null : dequeue();
} finally {
lock.unlock();
}
}
public E peek() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return itemAt(takeIndex); // null when queue is empty
} finally {
lock.unlock();
}
}