2019独角兽企业重金招聘Python工程师标准>>> 
Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构
Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接 口。
Queue的实现
1、没有实现的阻塞接口的LinkedList： 实现了java.util.Queue接口和java.util.AbstractQueue接口
内置的不阻塞队列： PriorityQueue 和 ConcurrentLinkedQueue
PriorityQueue 和 ConcurrentLinkedQueue 类在 Collection Framework 中加入两个具体集合实现。
PriorityQueue 类实质上维护了一个有序列表。加入到 Queue 中的元素根据它们的天然排序（通过其 java.util.Comparable 实现）或者根据传递给构造函数的 java.util.Comparator 实现来定位。
ConcurrentLinkedQueue 是基于链接节点的、线程安全的队列。并发访问不需要同步。因为它在队列的尾部添加元素并从头部删除它们，所以只要不需要知道队列的大 小， ConcurrentLinkedQueue 对公共集合的共享访问就可以工作得很好。收集关于队列大小的信息会很慢，需要遍历队列。
2、实现阻塞接口的：
java.util.concurrent 中加入了 BlockingQueue 接口和五个阻塞队列类。它实质上就是一种带有一点扭曲的 FIFO 数据结构。不是立即从队列中添加或者删除元素，线程执行操作阻塞，直到有空间或者元素可用。
五个队列所提供的各有不同：
* ArrayBlockingQueue ：一个由数组支持的有界队列。
* LinkedBlockingQueue ：一个由链接节点支持的可选有界队列。
* PriorityBlockingQueue ：一个由优先级堆支持的无界优先级队列。
* DelayQueue ：一个由优先级堆支持的、基于时间的调度队列。
* SynchronousQueue ：一个利用 BlockingQueue 接口的简单聚集（rendezvous）机制。
下表显示了jdk1.5中的阻塞队列的操作：
add 增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常
remove 移除并返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
element 返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
offer 添加一个元素并返回true 如果队列已满，则返回false
poll 移除并返问队列头部的元素 如果队列为空，则返回null
peek 返回队列头部的元素 如果队列为空，则返回null
put 添加一个元素 如果队列满，则阻塞
take 移除并返回队列头部的元素 如果队列为空，则阻塞
remove、element、offer 、poll、peek 其实是属于Queue接口。
阻塞队列的操作可以根据它们的响应方式分为以下三类：aad、removee和element操作在你试图为一个已满的队列增加元素或从空队列取得元素时 抛出异常。当然，在多线程程序中，队列在任何时间都可能变成满的或空的，所以你可能想使用offer、poll、peek方法。这些方法在无法完成任务时 只是给出一个出错示而不会抛出异常。
注意：poll和peek方法出错进返回null。因此，向队列中插入null值是不合法的
最后，我们有阻塞操作put和take。put方法在队列满时阻塞，take方法在队列空时阻塞。
LinkedBlockingQueue的容量是没有上限的（说的不准确，在不指定时容量为Integer.MAX_VALUE，不要然的话在put时怎么会受阻呢），但是也可以选择指定其最大容量，它是基于链表的队列，此队列按 FIFO（先进先出）排序元素。
ArrayBlockingQueue在构造时需要指定容量， 并可以选择是否需要公平性，如果公平参数被设置true，等待时间最长的线程会优先得到处理（其实就是通过将ReentrantLock设置为true来 达到这种公平性的：即等待时间最长的线程会先操作）。通常，公平性会使你在性能上付出代价，只有在的确非常需要的时候再使用它。它是基于数组的阻塞循环队 列，此队列按 FIFO（先进先出）原则对元素进行排序。
PriorityBlockingQueue是一个带优先级的 队列，而不是先进先出队列。元素按优先级顺序被移除，该队列也没有上限（看了一下源码，PriorityBlockingQueue是对 PriorityQueue的再次包装，是基于堆数据结构的，而PriorityQueue是没有容量限制的，与ArrayList一样，所以在优先阻塞 队列上put时是不会受阻的。虽然此队列逻辑上是无界的，但是由于资源被耗尽，所以试图执行添加操作可能会导致 OutOfMemoryError），但是如果队列为空，那么取元素的操作take就会阻塞，所以它的检索操作take是受阻的。另外，往入该队列中的元 素要具有比较能力。
DelayQueue（基于PriorityQueue来实现的）是一个存放Delayed 元素的无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且poll将返回null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时，则出现期满，poll就以移除这个元素了。此队列不允许使用 null 元素。
ArrayBlockingQueue 的源码解析
ArrayBlockingQueue类的结构如下：
public class ArrayBlockingQueue extends AbstractQueue
implements BlockingQueue, java.io.Serializable {
private static final long serialVersionUID = -817911632652898426L;
final Object[] items; //用数据来存储元素的容器
int takeIndex; //下一次读取或移除的位置（remove、poll、take ）
int putIndex; //下一次存放元素的位置（add、offer、put）
int count; //队列中元素的总数
final ReentrantLock lock; //所有访问的保护锁
private final Condition notEmpty; //等待获取元素的条件
private final Condition notFull; //等待存放元素的条件
略... 可以看出ArrayBlockingQueue内部使用final修饰的对象数组来存储元素，一旦初始化数组，数组的大小就不可改变。使用ReentrantLock锁来保证锁竞争，使用Condition来控制插入或获取元素时，线程是否阻塞。
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
//获得支持响应中断的锁
lock.lockInterruptibly();
try {
//使用while循环来判断队列是否已满，防止假唤醒
while (count == items.length)
notFull.await();
enqueue(e);
} finally {
lock.unlock();
}
}
首先获得锁，然后判断队列是否已满，如果已满则阻塞当前生产线程，直到队列中空闲时，被唤醒操作。队列空闲则调用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条件上等待的线程
notEmpty.signal();
}
把元素插入到队列中去，可以看出这个队列中的数组是环形数组结构，这样每次插入、移除的时候不需要复制移动数组中的元素。
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
//获得可响应中断锁
lock.lockInterruptibly();
try {
//使用while循环来判断队列是否已满，防止假唤醒
while (count == 0)
notEmpty.await();
return dequeue();
} finally {
lock.unlock();
}
}
消费者线程从阻塞队列中获取元素，如果队列中元素为空，则阻塞当前的消费者线程直到有数据时才调用dequeue方法获取元素。否则直接调用dequeue方法获取元素
private E dequeue() {
// assert lock.getHoldCount() == 1;
// assert items[takeIndex] != null;
final Object[] items = this.items;
@SuppressWarnings("unchecked")
//获取元素
E x = (E) items[takeIndex];
//将当前位置的元素设置为null
items[takeIndex] = null;
//这里可以看出这个数组是个环形数组
if (++takeIndex == items.length)
takeIndex = 0;
count--;
if (itrs != null)
//修改迭代器参数
itrs.elementDequeued();
// 唤醒在notFull条件上等待的线程
notFull.signal();
return x;
}
直接从数据中获取items[takeIndex]的元素，并设置当前位置的元素为null，并设置下一次takeIndex的坐标（++takeIndex），队列元素总数-1等操作。
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();
}
}
首先判断队列中的元素是否已满，如果已满则直接返回false，否则调用enqueue方法向队列中插入元素，插入成功返回true。
public E poll() {
final ReentrantLock lock = this.lock;
//获得不可响应中断的锁
lock.lock();
try {
return (count == 0) ? null : dequeue();
} finally {
lock.unlock();
}
}
判断队列是否为空，如果为空返回null，否则调用dequeue方法返回元素。
public boolean add(E e) {
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
首先调用offer方法插入元素，插入成功返回true，否则抛出IllegalStateException异常。
public E remove() {
E x = poll();
if (x != null)
return x;
else
throw new NoSuchElementException();
}
首先调用poll方法获取元素，如果不为空则直接返回，否则抛出NoSuchElementException异常。
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();
}
}
首先判断队列是否已满，如果已满再循环判断超时时间是否超时，超时则直接返回false，否则阻塞该生产线程nanos时间，如果nanos时间之内唤醒则调用enqueue方法插入元素。如果队列不满则直接调用enqueue方法插入元素，并返回true。
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();
}
}
首先循环判断队列是否为空，如果为空再判断是否超时，超时则返回null。不超时则等待，在nanos时间唤醒则调用dequeue方法获取元素。
public E element() {
E x = peek();
if (x != null)
return x;
else
throw new NoSuchElementException();
}
调用peek方法获取元素，元素不为空则返回，否则抛出NoSuchElementException异常。
public E peek() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return itemAt(takeIndex); // null when queue is empty
} finally {
lock.unlock();
}
}
final E itemAt(int i) {
return (E) items[i];
}
调用itemAt方法获取元素。
** 其它的阻塞队列实现原理都类似，都是使用ReentrantLock和Condition来完成并发控制、阻塞的。 **