来，回顾下 Java 中的各种队列…-技术圈

点击关注公众号，Java干货及时送达

作者：废物大师兄
来源：www.cnblogs.com/cjsblog/p/14140441.html

接下来就回顾一下各种队列。

Queue

队列是一种集合。

除了基本的集合操作以外，队列还提供了额外的插入、提取和检查操作。

队列的每个方法都以两种形式存在：一种是当操作失败时抛异常，另一种是返回一个特定的值（null或者false，取决于具体操作）。

后一种形式的插入操作是专门设计用于有界队列实现的，在大多情况下，插入操作不会失败。

队列通常（但不一定）以FIFO（先进先出）的方式对元素进行排序。例外情况包括优先级队列（根据提供的比较器对元素进行排序或元素的自然排序）和LIFO队列（或堆栈），对LIFO进行排序（后进先出）。

无论使用哪种顺序，队列的开头都是该元素，可以通过调用remove（）或poll（）将其删除。在FIFO队列中，所有新元素都插入队列的尾部。其他种类的队列可能使用不同的放置规则。每个Queue实现必须指定其排序属性。无论使用哪种顺序，都可以通过调用remove()或poll()来删除队列开头的元素。

在FIFO队列中，所有新元素都插入到队列的尾部。其他类型的队列可能使用不同的放置规则。每个队列实现都必须指定其排序属性。

offer方法在可以的情况下会向队列种插入一个元素，否则返回false。这不同于Collection.add方法，后者只能通过抛异常来添加元素。offer方法设计用于在正常情况下（而不是在例外情况下）发生故障时，例如在固定容量（或者“有界”）队列种使用。

remove()和poll()方法删除并返回队头元素。当队列为空时，remove()抛出异常，而poll()返回null。

element()和peek()方法返回队头元素。Java 系列面试题和答案我都整理好了，关注公众号Java技术栈在后台回复 "面试" 获取。

PriorityQueue

PriorityQueue是一个无界优先级队列是基于优先级堆的。优先级队列种的元素根据自然顺序进行排序，或者通过在队列构建时提供的Comparator进行排序，当然这取决于使用哪种构造函数。优先级队列不允许空（null）元素。一个依赖自然顺序的优先级队列也不允许插入不可比较的对象。

优先级队列的队头元素是最小的元素，如果有多个元素并列最小，那么队头是它们其中之一。

优先级队列是无界的，但是有一个内部容量来控制用于在队列上存储元素的数组的大小。它总是至少与队列大小一样大。将元素添加到优先级队列时，其容量会自动增长。

BlockingQueue

这种队列还支持以下操作：在检索元素时等待队列变为非空，并在存储元素时等待队列中的空间变为可用。

BlockingQueue方法有四种形式，它们以不同的方式处理操作，这些操作无法立即满足，但将来可能会满足：一种抛出异常，第二种返回特殊值（null或false，取决于具体操作），第三种阻塞当前线程，直到操作成功为止；第四种阻塞当前线程，超时则放弃。

下表总结了这些方法：

阻塞队列不接受空元素，如果你试图add , put 或者 offer 一个null，将会抛NullPointerException。推荐阅读：避免空指针的 5 个案例。

阻塞队列是线程安全的。所有排队方法都使用内部锁或者其他形式的并发控制来保证以原子方式实现它们的效果。

阻塞队列被设计主要用于生产者-消费者队列。

下面是一个典型的生产者-消费者方案：

package com.example;

import java.text.MessageFormat;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**
 * @author ChengJianSheng
 * @date 2020/12/15
 */
public class Setup {
    public static void main(String[] args) {
        BlockingQueue<Bread> queue = new ArrayBlockingQueue<>(5);

        Producer p1 = new Producer(queue);
        Producer p2 = new Producer(queue);
        Consumer c1 = new Consumer(queue);
        Consumer c2 = new Consumer(queue);

        new Thread(p1, "p1").start();
        new Thread(p2, "p2").start();
        new Thread(c1, "c1").start();
        new Thread(c2, "c2").start();
    }
}

class Bread {

}

/**
 * 生产者
 */
class Producer implements Runnable {

    private final BlockingQueue<Bread> queue;

    public Producer(BlockingQueue<Bread> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while (true) {
                queue.put(produce());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public Bread produce() {
        try {
            Thread.sleep(Math.round(2000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new Bread();
    }
}

/**
 * 消费者
 */
class Consumer implements Runnable {

    private final BlockingQueue<Bread> queue;

    public Consumer(BlockingQueue<Bread> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while (true) {
                consume(queue.take());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void consume(Bread bread) {
        try {
            Thread.sleep(Math.round(2000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}