Queue是一种很常见的数据结构类型，在Java里面Queue是一个接口，它只是定义了一个基本的Queue应该有哪些功能规约。实际上有多个Queue的实现，有的是采用线性表实现，有的基于链表实现。还有的适用于多线程的环境。java中具有Queue功能的类主要有如下几个：AbstractQueue, ArrayBlockingQueue, ConcurrentLinkedQueue, LinkedBlockingQueue, DelayQueue, LinkedList, PriorityBlockingQueue, PriorityQueue和ArrayDqueue。
Queue
Queue本身是一种先入先出的模型(FIFO)，和我们日常生活中的排队模型很类似。根据不同的实现，他们主要有数组和链表两种实现形式。如下图：
因为在队列里和我们日常的模型很近似，每次如果要出队的话，都是从队头移除。而如果每次要加入新的元素，则要在队尾加。所以我们要在队列里保存队头和队尾。
在jdk里几个常用队列实现之间的类关系图如下：
可以看到，Deque也是一个接口，它继承了Queue的接口规范。Queue作为一个接口，它声明的几个基本操作无非就是入队和出队的操作，具体定义如下：
-
public
interface Queue<E> extends Collection<E> {
-
-
boolean add(E e);
// 添加元素到队列中，相当于进入队尾排队。
-
-
boolean offer(E e);
//添加元素到队列中，相当于进入队尾排队.
-
-
E remove();
//移除队头元素
-
-
E poll();
//移除队头元素
-
-
E element();
//获取但不移除队列头的元素
-
-
E peek();
//获取但不移除队列头的元素
-
}
有了这些接口定义的规约，我们就可以很容易的在后续的详细实现里察看具体细节。
Deque
按照我们一般的理解，Deque是一个双向队列，这将意味着它不过是对Queue接口的增强。
如果仔细分析Deque接口代码的话，我们会发现它里面主要包含有4个部分的功能定义。
1. 双向队列特定方法定义。
2. Queue方法定义。
3. Stack方法定义。
4. Collection方法定义。
第3，4部分的方法相当于告诉我们，具体实现Deque的类我们也可以把他们当成Stack和普通的Collection来使用。这也是接口定义规约带来的好处。这里我们就不再赘述。DeQueue的定义如下：
-
public
interface Deque<E> extends Queue<E> {
-
-
void addFirst(E e);
-
-
void addLast(E e);
-
-
boolean offerFirst(E e);
-
-
boolean offerLast(E e);
-
-
E removeFirst();
-
-
E removeLast();
-
-
E pollFirst();
-
-
E pollLast();
-
-
E getFirst();
-
-
E getLast();
-
-
E peekFirst();
-
-
E peekLast();
-
-
boolean removeFirstOccurrence(Object o);
-
-
boolean removeLastOccurrence(Object o);
-
-
// *** Queue methods ***
-
boolean add(E e);
-
-
boolean offer(E e);
-
-
E remove();
-
-
E poll();
-
-
E element();
-
-
E peek();
-
-
// *** Stack methods ***
-
void push(E e);
-
-
E pop();
-
-
// *** Collection methods ***
-
boolean remove(Object o);
-
-
boolean contains(Object o);
-
-
public int size();
-
-
Iterator<E> iterator();
-
-
Iterator<E> descendingIterator();
-
}
下面将分别简单介绍几种常用的队列：ArrayDeque、ArrayBlockingQueue、PriorityQuue、PriorityBlockingQueue、LinkedBlockingDeque、LinkedBlockingQueue、ConcurrentLinkedDeque、ConcurrentLinkedQueue
1.ArrayDeque
ArrayDeque继承自AbstractCollection，是最简单的队列，有以下特征：
a. 采用数组存储数据，
b. 扩容也是采用2倍扩容的方式
c. 有head和tail两个成员变量，在队尾插入数据时，tail加1，从队头弹出数据时head+1，当head==tail时，便进行扩容。
ArrayDeque中在队尾插入数据的源码如下：
-
public void addLast(E e) {
-
if (e ==
null)
-
throw
new NullPointerException();
-
elements[tail] = e;
-
if ( (tail = (tail +
1) & (elements.length -
1)) == head)
-
doubleCapacity();
-
}
2.ArrayBlockingQueue
ArrayBlockingQueue也是采用数组存储数据的，但是它继承自AbstractQueue，之所以它是Blocking的是因为当put或poll数据时，如果Queue是满的或者没有数据，当前线程将阻塞等待，直到满足条件或当前线程被其他线程中断。它通过ReetranLock及其两个信号量notfFull和notEmpty实现线程安全的。构造函数如下：
-
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表示队首和队尾的成员变量分别是tableIndex和putIndex，定义如下：
-
/** items index for next take, poll, peek or remove */
-
int takeIndex;
-
-
/** items index for next put, offer, or add */
-
int putIndex;
-
-
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();
-
}
-
}
-
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();
-
}
-
-
public E poll() {
-
final ReentrantLock lock =
this.lock;
-
lock.lock();
-
try {
-
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;
-
if (++takeIndex == items.length)
-
takeIndex =
0;
-
count--;
-
if (itrs !=
null)
-
itrs.elementDequeued();
-
notFull.signal();
-
return x;
-
}
除了通用的put和poll方法外，ArrayBlockingQueue还提供了带定时参数的put和poll方法，即如果无法取得相应的信号量，将等待固定的时间后返回，源码如下：
-
-
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();
-
}
-
}
-
-
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();
-
}
-
}
a. 用数组存储数据
b. 容量固定，不支持扩容，构造时必须插入容量值
c. 通过同步锁和信号量实现了线程安全。
d. 实现了Queue接口的方法，同时提供超时返回的offer和poll方法
e. 由于是线程安全的，因此不会有fail-fast问题。
3.PriorityQueue
PriorityQuue继承自AbstractQueue，通过构造函数传入的Comparator或者数据成员实现的Comparable接口的方法来确定成员间的优先级。PriorityQueue也是采用数组存储数据的，它只保证队首是最小的，其他的不保证顺序。插入时，会采用二分法将数据插入到最前面（注意，PriorityQueue是支持扩容的）插入数据的源码如下：
-
-
public boolean offer(E e) {
-
if (e ==
null)
-
throw
new NullPointerException();
-
modCount++;
-
int i = size;
-
if (i >= queue.length)
-
grow(i +
1);
-
size = i +
1;
-
if (i ==
0)
-
queue[
0] = e;
-
else
-
siftUp(i, e);
-
return
true;
-
}
-
-
private void siftUp(int k, E x) {
-
if (comparator !=
null)
-
siftUpUsingComparator(k, x);
-
else
-
siftUpComparable(k, x);
-
}
-
-
@SuppressWarnings(
"unchecked")
-
private void siftUpComparable(int k, E x) {
-
Comparable<?
super E> key = (Comparable<?
super E>) x;
-
while (k >
0) {
-
int parent = (k -
1) >>>
1;
-
Object e = queue[parent];
-
if (key.compareTo((E) e) >=
0)
-
break;
-
queue[k] = e;
-
k = parent;
-
}
-
queue[k] = key;
-
}
-
-
@SuppressWarnings(
"unchecked")
-
private void siftUpUsingComparator(int k, E x) {
-
while (k >
0) {
-
int parent = (k -
1) >>>
1;
-
Object e = queue[parent];
-
if (comparator.compare(x, (E) e) >=
0)
-
break;
-
queue[k] = e;
-
k = parent;
-
}
-
queue[k] = x;
-
}
弹出队首数据时，先将队首数据保存，然后将队尾数据放到队首后再按照父节点小于子节点的原则下降，弹出数据源码如下：
-
public E poll() {
-
if (size ==
0)
-
return
null;
-
int s = --size;
-
modCount++;
-
E result = (E) queue[
0];
-
E x = (E) queue[s];
-
queue[s] =
null;
-
if (s !=
0)
-
siftDown(
0, x);
-
return result;
-
}
-
-
private void siftDown(int k, E x) {
-
if (comparator !=
null)
-
siftDownUsingComparator(k, x);
-
else
-
siftDownComparable(k, x);
-
}
-
-
@SuppressWarnings(
"unchecked")
-
private void siftDownComparable(int k, E x) {
-
Comparable<?
super E> key = (Comparable<?
super E>)x;
-
int half = size >>>
1;
// loop while a non-leaf
-
while (k < half) {
-
int child = (k <<
1) +
1;
// assume left child is least
-
Object c = queue[child];
-
int right = child +
1;
-
if (right < size &&
-
((Comparable<?
super E>) c).compareTo((E) queue[right]) >
0)
-
c = queue[child = right];
-
if (key.compareTo((E) c) <=
0)
-
break;
-
queue[k] = c;
-
k = child;
-
}
-
queue[k] = key;
-
}
-
-
@SuppressWarnings(
"unchecked")
-
private void siftDownUsingComparator(int k, E x) {
-
int half = size >>>
1;
-
while (k < half) {
-
int child = (k <<
1) +
1;
-
Object c = queue[child];
-
int right = child +
1;
-
if (right < size &&
-
comparator.compare((E) c, (E) queue[right]) >
0)
-
c = queue[child = right];
-
if (comparator.compare(x, (E) c) <=
0)
-
break;
-
queue[k] = c;
-
k = child;
-
}
-
queue[k] = x;
-
}
总结一下PriorityQueue的特征如下：
a. 采用数组存储数据
b. 支持扩容，当长度小于64时按+2扩容，否则按2倍扩容
c. 按Comparable接口或Comparator确定优先级
d. 队首的数据是最小的，但不保证其他数据的顺序。
e. 节点k的父节点是k/2，父节点的值小于子节点。
4.PriorityBlockingQueue
PriorityBlockingQueue继承自AbstractQueue，实现同PriorityQueue大同小异，只不过在对数据进行操作前使用了ReentrantLock实现了线程同步，PriorityBlockingQueue具有以下特征：
a. 具有所有PriorityQueue的特征
b. 采用同步锁实现线程安全
c. 由于支持扩容，因此add数据时，只需获取lock锁，不需要获取信号量
d. poll时需要获取notEmpty信号量，同时提供了超时退出的poll方法
5. LinkedBlockingDeque
LinkedBlockingDeque继承自AbstractQueue，采用链表结构存储数据，同时使用ReentrantLock保证线程安全，同时有notEmpty和notFull两个信号量。总结如下：
a. 采用链表存储数据，但容量固定，默认容量为最大整数。
b. 使用同步锁保证线程安全
c. 可以在队首和队尾插入或删除数据
d. 插入数据时，先获取lock，然后获取notFull信号量，插入后重置notEmpty信号量
e. 弹出数据时，先获取lock，得到数据后，重置notFull信号量（无数据时pop和poll方法会返回，takeFirst和takeLast会等待notEmpty信号量）
f. 提供了插入或弹出数据对应的超时返回方法。
6. LinedBlockingQueue
LinkedBlockingQueue也是继承自AbstractQueue，采用链表存储数据，它和LinkedBlockingDeque的区别在于，它有两把同步锁putLock和takeLock，分别控制数据的写入和弹出，并且它只能在队尾插入数据，从队首弹出数据。总结如下：
a. 采用链表存储数据，但容量固定，默认容量为最大整数
b. 读写分离的，有两把同步锁：写锁putLock和读锁takeLock
c. 只能在队尾插入数据，从队首弹出数据
d. 插入数据时，获取putLock锁，并等待notFull信号量，插入数据完成后，重置notEmpty信号量，如果队列没满则重置notFull信号量。
e. 弹出数据时，获取takeLock锁，获取到数据后，重置notFull信号量，如果队列仍不为空，重置notEmpty信号量。
7.ConcurrentLinkedQueue
ConcurrentLinkedQueue继承自AbstractQueue，采用链表存储数据，与上述几个实现线程的Queue方法不同，它通过Unsafe的CAS（compareAndSwap）方法实现线程安全（Unsafe相当于在JVM底层通过操作内存修改数据，如果在修改过程中数据没改变则替换成要修改的值，否则修改失败），总结如下：
a. 用链表存储数据，没有限制容量
b. 使用Unsafe类实现线程安全
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
