队列（Queue）：一种与栈相对的数据结构， 集合（Collection）一个子类。队列允许在一端插入，而在另一端删除线性表。堆栈的特点是先进先出，而队列的特点是先进先出。队列非常有用，比如实现新闻队列。
Queue 类关系图如下图所示：
注：为了让读者更直观地理解，上图是精简版 Queue 类关系图。如果本文没有特别说明，则内容是基于 Java 1.8 版本。
队列（Queue）1）Queue 分类从上图可以看出 Queue 一般可分为以下三类。
- 双端队列：双端队列（Deque）是 Queue 的子类也是 Queue 头部和尾部都支持元素的插入和获取。
- 阻塞队列：阻塞队列是指在元素操作（添加或删除）时，如果不成功，将阻塞等待执行。例如，当添加元素时，如果队列元素已满，队列将被阻塞，直到空位插入。
- 非阻塞队列：与阻塞队列相反，非阻塞队列将直接返回操作结果，而不是阻塞等待。双端队列也属于非阻塞队列。
Queue 常用方法如下图所示：
方法说明：
- add(E)：将元素添加到队列尾部，成功返回 true，超出队列时抛出异常；
- offer(E)：将元素添加到队列尾部，成功返回 true，当队列超过时返回 false；
- remove()：删除元素，成功返回 true，失败返回 false；
- poll()：获取并移除队列的第一个元素，如果队列是空的，则返回 null；
- peek()：获取但不移除队列的第一个元素，如果队列是空的，则返回 null；
- element()：获取但不移除队列的第一个元素，如果队列是空的，则抛出异常。
Queue<String> linkedList = new LinkedList<>();linkedList.add("Dog");linkedList.add("Camel");linkedList.add("Cat");while (!linkedList.isEmpty()) { System.out.println(linkedList.poll());}程序执行结果：
阻塞队列1）BlockingQueueDog
Camel
Cat
BlockingQueue 在 java.util.concurrent 包下，实现其他阻塞类 BlockingQueue 接口，BlockingQueue 线程安全的队列访问提供了一种方式。当将数据插入到队列中时，如果队列满了，线程将阻止等待队列中的元素被取出，然后插入；当从队列中获取数据时，如果队列是空的，线程将被阻塞，等待队列中的新元素再次获得。
BlockingQueue 核心方法
插入方法：
- add(E)：将元素添加到队列尾部，成功返回 true，超出队列时抛出异常；
- offer(E)：将元素添加到队列尾部，成功返回 true，当队列超过时返回 false ；
- put(E)：将元素插入队列的尾部，如果队列满了，就会被堵塞。 删除方法：
- remove(Object)：移除指定元素，成功返回 true，失败返回 false；
- poll()： 获取并移除队列的第一个元素，如果队列是空的，则返回 null；
- take()：如果没有元素，队列的第一个元素就会被获取和移除。 检查方法：
- peek()：获取但不移除队列的第一个元素，如果队列是空的，则返回 null。
LinkedBlockingQueue 是链表实现的有界阻塞队列，容量默认值为 Integer.MAX_VALUE，还可定制容量，建议指定容量大小，默认大小在添加速度大于删除速度时有内存溢出的风险，LinkedBlockingQueue 以先进先出的方式存储元素。
3）ArrayBlockingQueueArrayBlockingQueue 它是一个有边界的阻塞队列，其内部实现是一个数组。它的容量是有限的，我们必须在初始化时指定它的容量，一旦指定它就不能改变。
ArrayBlockingQueue 存储数据也是一种先进先出的方式，ArrayBlockingQueue 内部阻塞队列通过重新进入锁定 ReenterLock 和 Condition 因此，实现了条件队列 ArrayBlockingQueue 公平访问和非公平访问之间存在差异，对于公平访问队列，阻塞的线程可以按照阻塞的顺序访问队列，即先阻塞的线程。而不是公平的队列，当队列可用时，阻塞的线程将进入竞争访问资源，也就是说，没有固定的顺序。
示例代码如下：
// 默许非公平阻塞队列ArrayBlockingQue queue = new ArrayBlockingQueue(6);// ArrayBlockingueue公平阻塞队列 queue2 = new ArrayBlockingQueue(6,true);// ArrayBlockingQueue publicicc源代码显示 ArrayBlockingQueue(int capacity) { this(capacity, false);}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();}DelayQueue 它是一个支持延迟获取元素的无限阻塞队列，必须实现队列中的元素 Delayed 界面，在创建元素时，可以指定延迟时间，只有在达到延迟时间后才能获得元素。
实现了 Delayed 接口必须重写两种方法 ，getDelay(TimeUnit) 和 compareTo(Delayed)，如下代码所示：
class DelayElement implements Delayed { @Override // 剩余时间 public long getDelay(TimeUnit unit) { // do something } @Override // 队列中元素的排序依据 public int compareTo(Delayed o) { // do something } }DelayQueue 请参考以下代码：
public class DelayTest { public static void main(String[] args) throws InterruptedException { DelayQueue delayQueue = new DelayQueue(); delayQueue.put(new DelayElement(1000)); delayQueue.put(new DelayElement(3000)); delayQueue.put(new DelayElement(5000)); System.out.println(“开始时间：” + DateFormat.getDateTimeInstance().format(new Date())); while (!delayQueue.isEmpty()){ System.out.println(delayQueue.take()); } System.out.println“结束时间：” + DateFormat.getDateTimeInstance().format(new Date())); } static class DelayElement implements Delayed { // 延迟截止时间(单面:毫秒) long delayTime = System.currentTimeMillis(); public DelayElement(long delayTime) { this.delayTime = (this.delayTime + delayTime); } @Override // 剩余时间 public long getDelay(TimeUnit unit) { return unit.convert(delayTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS); } @Override // 队列中元素的排序依据 public int compareTo(Delayed o) { if (this.getDelay(TimeUnit.MILLISECONDS) > o.getDelay(TimeUnit.MILLISECONDS)) { return 1; } else if (this.getDelay(TimeUnit.MILLISECONDS) < o.getDelay(TimeUnit.MILLISECONDS)) { return -1; } else { return 0; } } @Override public String toString() { return DateFormat.getDateTimeInstance().format(new Date(delayTime)); } }}程序执行结果：
非阻塞队列开始时间：2019-6-13 20:40:38
2019-6-13 20:40:39
2019-6-13 20:40:41
2019-6-13 20:40:43
结束时间：2019-6-13 20:40:43
ConcurrentLinkedQueue 它是一个基于链接节点的无限线程安全队列。它使用先进先出的规则对节点进行排序。当我们添加一个元素时，它会添加到队列的尾部；当我们得到一个元素时，它会返回到队列的头部。
其入队和出队操作均采用 CAS（Compare And Set）更新允许多线程并发执行，不会因锁定而堵塞线程，使并发性能更好。
ConcurrentLinkedQueue 使用示例：
ConcurrentLinkedQueue concurrentLinkedQueue = new ConcurrentLinkedQueue();concurrentLinkedQueue.add("Dog");concurrentLinkedQueue.add("Cat");while (!concurrentLinkedQueue.isEmpty()) { System.out.println(concurrentLinkedQueue.poll());}执行结果：
Dog
Cat
可以看出，无论是阻塞队列还是非阻塞队列，使用方法都是相似的，区别在于底层的实现。
优先级队列PriorityQueue 基于优先级堆的无限优先级队列。优先级队列的元素按自然顺序排列，或根据构建队列时提供的元素进行排序 Comparator 排序取决于所使用的结构方法。优先级队列不允许使用 null 元素。
PriorityQueue 代码使用示例：
Queue<Integer> priorityQueue = new PriorityQueue(new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { // 非自然排序，数字倒序 return o2 - o1; }});priorityQueue.add(3);priorityQueue.add(1);priorityQueue.add(2);while (!priorityQueue.isEmpty()) { Integer i = priorityQueue.poll(); System.out.println(i);}程序执行的结果如下：
3
2
1
PriorityQueue 注意的点：
- PriorityQueue 非线程安全，可用于多线程 PriorityBlockingQueue 类替代；
- PriorityQueue 不允许插入 null 元素。
答：ArrayBlockingQueue 和 LinkedBlockingQueue 所有这些都实现了自堵队列 BlockingQueue，它们的区别主要体现在以下几个方面：
- ArrayBlockingQueue 使用时必须指定容量值，LinkedBlockingQueue 不需要指定；
- ArrayBlockingQueue 使用时指定最大容量值，指定后不得修改；而且 LinkedBlockingQueue 最大容量是 Integer.MAX_VALUE；
- ArrayBlockingQueue 数据存储容器采用数组存储； LinkedBlockingQueue 采用的是 Node 存储节点。
答：add() 和 offer() 将元素添加到队列尾部。offer 方法是基于 add 实现方法，Offer 源代码如下：
public boolean offer(E e) { return add(e);}答：Queue 属于一般队列，Deque 属于双端队列。一般队列先进先出，即只有先进才能先出；双端队列可以在两端插入和删除元素。
4.LinkedList 属于一般队列还是双端队列？答：LinkedList 实现了 Deque 属于双端队列，所以有 addFirst(E)、addLast(E)、getFirst()、getLast() 等方法。
5.以下说法是错误的？A：DelayQueue 内部是基于 PriorityQueue 实现的B：PriorityBlockingQueue C不是先进先出的数据存储方法：LinkedBlockingQueue 默认容量是无限的D：ArrayBlockingQueue 内部存储单元为数组，初始化时必须指定队列容量
答：C
题目解析：LinkedBlockingQueue 默认容量是 Integer.MAX_VALUE，并非无限大。
6.关于 ArrayBlockingQueue 说法不正确的是吗？A：ArrayBlockingQueue 是线程安全的B：ArrayBlockingQueue 元素允许为 nullC：ArrayBlockingQueue 主要应用场景是“生产者-消费者”模型D：ArrayBlockingQueue 设置容量必须显示
答：B
题目解析：ArrayBlockingQueue 不允许元素为 null，若添加一个 null 元素，会抛 NullPointerException 异常。
7.执行以下程序的结果是什么？PriorityQueue priorityQueue = new PriorityQueue();priorityQueue.add(null);System.out.println(priorityQueue.size());答:程序执行报错，PriorityQueue 不能插入 null。
8.Java 常见的阻塞队列有哪些？答：Java 常见的阻塞队列如下：
- ArrayBlockingQueue，由数组结构组成的有界阻塞队列；
- PriorityBlockingQueue，无限阻塞队列支持优先级排名；
- SynchronousQueue，它是一个不存储元素的阻塞队列，将直接将任务交给消费者，必须等到队列中的添加元素被消耗后才能继续添加新元素；
- LinkedBlockingQueue，由链表结构组成的阻塞队列；
- DelayQueue，无限阻塞队列支持延迟获取元素。
答:有界队列和无界队列的区别如下。
- 有界队列：有固定大小的队列称为有界队列，例如：new ArrayBlockingQueue(6)，6 是队列的大小。
- 无界队列:指没有固定大小的队列，可以直接列入，直到溢出。它们并不是真的无界，它们的最大值通常是 Integer.MAX_VALUE，只是很少使用这么大的容量(超过 Integer.MAX_VALUE），因此，从用户体验来看，相当于 “无界”。
A:说到延迟消息队列，我们应该能够第一次考虑使用它 DelayQueue 延迟队列来解决这个问题。实现想法，新闻队列分为生产者和消费者，生产者用来增加新闻，消费者用来获取和消费新闻，我们只需要生产者把新闻放进去 DelayQueue 队列并设置延迟时间，消费者可回收利用 take() 阻止获取消息。完整的实现代码如下：
public class CustomDelayQueue { // 消息编号 static AtomicInteger MESSAGENO = new AtomicInteger(1); public static void main(String[] args) throws InterruptedException { DelayQueue<DelayedElement> delayQueue = new DelayQueue<>(); // 生产者1 producer(delayQueue, “生产者1”; // 生产者2 producer(delayQueue, “生产者2”; // 消费者 consumer(delayQueue); } //生产者 private static void producer(DelayQueue<DelayedElement> delayQueue, String name) { new Thread(new Runnable() { @Override public void run() { while (true) { // 产生 1~5 秒的随机数 long time = 1000L * (new Random().nextInt(5) + 1); try { Thread.sleep(time); } catch (InterruptedException e) { e.printStackTrace(); } // 组合消息体 String message = String.format("%s，消息编号：%：s 发送时间：%：%s 延迟：%s 秒", name, MESSAGENO.getAndIncrement(), DateFormat.getDateTimeInstance().format(new Date()), time / 1000); // 生产消息 delayQueue.put(new DelayedElement(message, time)); } } }).start(); } //消费者 private static void consumer(DelayQueue<DelayedElement> delayQueue) { new Thread(new Runnable() { @Override public void run() { while (true) { DelayedElement element = null; try { // 消费消息 element = delayQueue.take(); System.out.println(element); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); } // 延迟队列对象 static class DelayedElement implements Delayed { // 过期时间(单位:毫秒) long time = System.currentTimeMillis(); // 消息体 String message; // 参数：delayTime 延迟时间(单位m秒) public DelayedElement(String message, long delayTime) { this.time += delayTime; this.message = message; } @Override // 获取过期时间 public long getDelay(TimeUnit unit) { return unit.convert(time - System.currentTimeMillis(), TimeUnit.MILLISECONDS); } @Override // 排序队列元素 public int compareTo(Delayed o) { if (this.getDelay(TimeUnit.MILLISECONDS) > o.getDelay(TimeUnit.MILLISECONDS)) return 1; else if (this.getDelay(TimeUnit.MILLISECONDS) < o.getDelay(TimeUnit.MILLISECONDS)) return -1; else return 0; } @Override public String toString() { // 打印消息 return message + " |执行时间：" + DateFormat.getDateTimeInstance().format(new Date()); } }}上述程序支持多个生产者，执行结果如下：
总结生产者1，消息编号：1 发送时间：2019-6-12 20:38:37 延迟：2 秒 |执行时间:2019-6-12 20:38:39
生产者2，消息编号：2 发送时间：2019-6-12 20:38:37 延迟：2 秒 |执行时间:2019-6-12 20:38:39
生产者1，消息编号：3 发送时间：2019-6-12 20:38:41 延迟：4 秒 |执行时间:2019-6-12 20:38:45
生产者1，消息编号：5 发送时间：2019-6-12 20:38:43 延迟：2 秒 |执行时间:2019-6-12 20:38:45
...
队列（Queue）根据阻塞是否可分为：阻塞队列 BlockingQueue 和 非阻塞队列。其中，双端队列 Deque 它也属于非阻塞队列。除了先进先出的队列方法外，双端队列还有自己独特的方法，如 addFirst()、addLast()、getFirst()、getLast() 支持未插入和删除元素。队列中常用的两个队列 PriorityQueue(优先级队列)和 DelayQueue(延迟队列)可以使用延迟队列来实现延迟消息队列，这也是面试中常见的问题之一。需要面试的朋友一定要知道延迟队列，写一个消息队列也是很有必要的。
湘公网安备43019002002060