1 简介
队列是一种特殊的线性表，遵循的原则就是“先入先出”。在我们日常使用中，经常会用来并发操作数据。在并发编程中，有时候需要使用线程安全的队列。如果要实现一个线程安全的队列通常有两种方式：一种是使用阻塞队列，另一种是使用线程同步锁。
2 Queue的实现
2.1 非阻塞队列
LinkedList： 实现了java.util.Queue接口、java.util.AbstractQueue接口、java.util.List
PriorityQueue 类实质上维护了一个有序列表。加入到 Queue 中的元素根据它们的天然排序（通过其 java.util.Comparable 实现）或者根据传递给构造函数的 java.util.Comparator 实现来定位。
ConcurrentLinkedQueue 是基于链接节点的、线程安全的队列。并发访问不需要同步。因为它在队列的尾部添加元素并从头部删除它们，所以只要不需要知道队列的大 小，ConcurrentLinkedQueue 对公共集合的共享访问就可以工作得很好。收集关于队列大小的信息会很慢，需要遍历队列。
2.2 阻塞队列
java.util.concurrent 中加入了 BlockingQueue 接口和五个阻塞队列类。它实质上就是一种带有一点扭曲的 FIFO 数据结构。不是立即从队列中添加或者删除元素，线程执行操作阻塞，直到有空间或者元素可用。
五个队列所提供的各有不同：
* ArrayBlockingQueue ：一个由数组支持的有界队列。
* LinkedBlockingQueue ：一个由链接节点支持的可选有界队列。
* PriorityBlockingQueue ：一个由优先级堆支持的无界优先级队列。
* DelayQueue ：一个由优先级堆支持的、基于时间的调度队列。
* SynchronousQueue ：一个利用 BlockingQueue 接口的简单聚集（rendezvous）机制。
阻塞队列的操作：
- clear() ：从队列彻底移除所有元素。
- iterator() ： 返回在队列中的元素上按适当顺序进行迭代的迭代器，返回值为 Iterator。
- offer(E e) ：将指定元素插入到此队列的尾部（如果立即可行且不会超出此队列的容量），在成功时返回 true，如果此队列已满，则返回 false。
- offer(E e, long timeout, TimeUnit unit) ：将指定元素插入到此队列的尾部，如有必要，则等待指定的时间以使空间变得可用。
- peek() ： 获取但不移除此队列的头；如果此队列为空，则返回 null。
- poll() ：获取并移除此队列的头，如果此队列为空，则返回 null。
- poll(long timeout, TimeUnit unit) ：获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。
- put(E e) ：将指定元素插入到此队列的尾部，如有必要，则等待空间变得可用。
- remainingCapacity() ：返回理想情况下（有界队列没有内存和资源约束）此队列可接受并且不会被阻塞的附加元素数量。
- remove(Object o) ：从此队列移除指定元素的单个实例（如果存在），返回值为Boolean。
- size() ：返回队列中的元素个数。
- take() ：获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。
- Object[] toArray() ：返回按适当顺序包含此队列中所有元素的数组。
- toString() ：返回此 collection 的字符串表示形式，返回值为String。
remove、element、offer 、poll、peek 其实是属于Queue接口。
阻塞队列的操作可以根据它们的响应方式分为以下三类：aad、removee和element操作在你试图为一个已满的队列增加元素或从空队列取得元素时 抛出异常。当然，在多线程程序中，队列在任何时间都可能变成满的或空的，所以你可能想使用offer、poll、peek方法。这些方法在无法完成任务时 只是给出一个出错示而不会抛出异常。
注意：poll和peek方法出错进返回null。因此，向队列中插入null值是不合法的
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 元素。
2.3 常用队列举例
package util.queue;
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
/**
*
*/
public class LinkedBlockingQueueDemo {
public static void main(String[] args) {
/**
* 1、LinkedBlockingQueue(int capacity)：
* 创建一个具有给定（固定）容量的 LinkedBlockingQueue
*
* 2、LinkedBlockingQueue() ：
* 创建一个容量为 Integer.MAX_VALUE 的 LinkedBlockingQueue，
*/
LinkedBlockingQueue<Integer> linkedBlockingQueue = new LinkedBlockingQueue(5);
//1、put(E e)：将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间,无返回值
try {
linkedBlockingQueue.put(6);
System.out.println("put后：" + linkedBlockingQueue.peek());
} catch (InterruptedException e) {
e.printStackTrace();
}
//2、peek()：将指定元素插入到此队列的尾部，如有必要，则等待空间变得可用。
Integer peekResult = linkedBlockingQueue.peek();
System.out.println("peekResult: " + peekResult);
/**
* 3.1、poll()：获取并移除此队列的头，如果此队列为空，则返回 null。
* 3.2、poll(long timeout, TimeUnit unit)：获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。
*/
Integer pollResult = linkedBlockingQueue.poll();
System.out.println("pollResult: " + pollResult);
Integer afterPollResult = linkedBlockingQueue.poll();
System.out.println("poll后的结果: " + afterPollResult);
/**
* 4.1 offer(E e) ： 将指定元素插入到此队列的尾部（如果立即可行且不会超出此队列的容量），
* 在成功时返回 true，如果此队列已满，则返回 false。
*
* 4.2 offer(E e, long timeout, TimeUnit unit)：将指定元素插入到此队列的尾部，
* 如有必要，则等待指定的时间以使空间变得可用
*/
Boolean offerBoolean = linkedBlockingQueue.offer(7);
System.out.println("是否成功offer: " + offerBoolean);
//5、remove(Objec8t o): 从此队列移除指定元素的单个实例（如果存在）。。返回值为Boolean
Boolean remove8Boolean = linkedBlockingQueue.remove(8);
System.out.println("移除8是否成功：" + remove8Boolean);
Boolean remove7Boolean = linkedBlockingQueue.remove(7);
System.out.println("移除7是否成功：" + remove7Boolean);
//6、size()：返回此队列中元素的数量。
try {
linkedBlockingQueue.put(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
int sizeQueue = linkedBlockingQueue.size();
System.out.println("arrayBlockingQueue.size = " + sizeQueue);
//7、remainingCapacity()：返回理想情况下（没有内存和资源约束）此队列可接受并且不会被阻塞的附加元素数量
try {
linkedBlockingQueue.put(8);
linkedBlockingQueue.put(9);
linkedBlockingQueue.put(10);
Integer numbers = linkedBlockingQueue.remainingCapacity();
System.out.println("此队列可接受并且不会被阻塞的附加元素数量: " + numbers);
} catch (InterruptedException e) {
e.printStackTrace();
}
//8、iterator() 返回在此队列中的元素上按适当顺序进行迭代的迭代器，返回值为Iterator<E>
Iterator<Integer> iterator = linkedBlockingQueue.iterator();
while (iterator.hasNext()){
Integer result = iterator.next();
System.out.println("iterator的结果result: " + result);
}
//9、take()：获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。
try {
Integer takeResult = linkedBlockingQueue.take();
System.out.println("takeResult: " + takeResult);
} catch (InterruptedException e) {
e.printStackTrace();
}
//10、clear()： 从队列彻底移除所有元素。
linkedBlockingQueue.clear();
System.out.println("看一下是否还存在元素：" + linkedBlockingQueue.peek());
}
}
