阻塞队列

对比“非阻塞队列”

　　相对于ConcurrentLinkedQueue这种非阻塞队列而言，阻塞队列提供了阻塞机制，即在队列不可用时（队满无法入队，队空无法出队），对线程进行阻塞，直至队列可用时再唤醒线程。在队列不可用时，各种处理方法如下图。
　　

　　ConcurrentLinkedQueue提供了抛出异常和返回特殊值两种出入队方法，阻塞队列则另外提供了后面两种。需要注意的是，如果是无界阻塞队列，队列不可能出现满的情况，所以使用put或offer方法永远不会被阻塞，而且offer方法永远返回true。

阻塞队列对比

队列类 是否有界 公平性 主要特性 ArrayBlockingQueue 有 默认不公平，可以设置为公平 LinkedBlockingQueue 有 PriorityBlockingQueue 无 元素按优先级排序 DelayQueue 无 创建元素时可以指定多久才能从队列中获取当前元素 SynchronousQueue 有 默认不公平，可以设置为公平 不存储元素。每一个put操作必须等待一个take操作，否则不能继续添加元素 LinkedTransferQueue 无 带有transfer方法 LinkedBlockingDeque 有 可以从队列两端进行入队和出队

ArrayBlockingQueue

　　ArrayBlockingQueue是一个用数组实现的有界阻塞队列，默认不保证线程的公平访问（即当队列可用时，多个被阻塞的线程不会按先到先得原则来访问），可以通过以下方式声明一个公平的ArrayBlockingQueue实例。

ArrayBlockingQueue<Object> fairQueue = new ArrayBlockingQueue<Object>(1000,true);

LinkedBlockingQueue

　　LinkedBlockingQueue是一个用链表实现的有界阻塞队列，默认长度和最大长度为Integer.MAX_VALUE。

PriorityBlockingQueue

PriorityBlockingQueue是一个支持按照优先级排序的无界阻塞队列，但不保证同等优先级元素的排列顺序。优先级必须通过以下两种方式之一指定。

1. 添加到队列的对象需要实现java.lang.Comparable接口。
2. 使用以下构造方法创建队列实例，并指定comparator。

public PriorityBlockingQueue(int initialCapacity,                                 Comparator<? super E> comparator) {        if (initialCapacity < 1)            throw new IllegalArgumentException();        this.lock = new ReentrantLock();        this.notEmpty = lock.newCondition();        this.comparator = comparator;        this.queue = new Object[initialCapacity];}

DelayQueue

　　DelayQueue是一个支持延时获取元素的无界阻塞队列。队列使用PriorityQueue来实现。队列中的元素必须实现Delayed接口，在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。需要注意的是，DelayQueue不保证线程的公平访问（即当队列可用时，多个被阻塞的线程不会按先到先得原则来访问）。可以将DelayQueue运用在以下应用场景：

1. 缓存系统的设计：可以用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue中获取元素时，表示缓存有效期到了。
2. 定时任务调度:使用DelayQueue保存当天将会执行的任务和执行时间，一旦从DelayQueue中获取到任务就开始执行，比如TimerQueue就是使用DelayQueue实现的。

实现Delayed接口

DelayQueue队列中的元素必须实现Delayed接口。具体实现可以参考ScheduledThreadPoolExecutor里ScheduledFutureTask类。

//Delayed接口声明public interface Delayed extends Comparable<Delayed> {    /**     * Returns the remaining delay associated with this object, in the     * given time unit.     *     * @param unit the time unit     * @return the remaining delay; zero or negative values indicate     * that the delay has already elapsed     */    long getDelay(TimeUnit unit);}

//ScheduledFutureTask的具体实现//构造方法ScheduledFutureTask(Runnable r, V result, long ns, long period) {    super(r, result);    this.time = ns;    this.period = period;    this.sequenceNumber = sequencer.getAndIncrement();}//返回当前元素还需要延时多少时间，单位为纳秒public long getDelay(TimeUnit unit) {    return unit.convert(time - now(), NANOSECONDS);}//使用compareTo方法来指定元素的顺序，下面的代码让延时时间最长的元素放在队列的末尾public int compareTo(Delayed other) {    if (other == this) // compare zero if same object        return 0;    if (other instanceof ScheduledFutureTask) {        ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;        long diff = time - x.time;        if (diff < 0)            return -1;        else if (diff > 0)            return 1;        else if (sequenceNumber < x.sequenceNumber)            return -1;        else            return 1;    }    long diff = getDelay(NANOSECONDS) - other.getDelay(NANOSECONDS);    return (diff < 0) ? -1 : (diff > 0) ? 1 : 0;}

DelayQueue具体实现

private final PriorityQueue<E> q = new PriorityQueue<E>();private final transient ReentrantLock lock = new ReentrantLock();private Thread leader = null;//用于通知队头节点可用private final Condition available = lock.newCondition();public boolean offer(E e) {    final ReentrantLock lock = this.lock;    lock.lock();    try {        q.offer(e);        if (q.peek() == e) {            leader = null;            available.signal();        }        return true;    } finally {        lock.unlock();    }}//获取队头节点，如果延迟时间小于等于0，则返回该节点，否则返回nullpublic E poll() {    final ReentrantLock lock = this.lock;    lock.lock();    try {        E first = q.peek();        if (first == null || first.getDelay(NANOSECONDS) > 0)            return null;        else            return q.poll();    } finally {        lock.unlock();    }}/** * 1.如果头节点为空，则调用available.await()进入阻塞态 * 2.如果头节点不为空，并且延迟时间小于等于0，则返回头节点 * 3.如果头节点不为空，并且延迟时间大于0 * 　1）如果leader不等于当前线程，则调用available.await()进入阻塞态 * 　2）否则调用available.awaitNanos(delay)进入阻塞态（防止多个线程同时进入等待状态而没有其他线程来唤醒） * 4.在线程获取到节点后，在方法的最后需要判断是否需要调用available.signal() * 当入队时，会调用available.signal()唤醒第一个等待的线程。 */public E take() throws InterruptedException {    final ReentrantLock lock = this.lock;    lock.lockInterruptibly();    try {        for (;;) {            E first = q.peek();            if (first == null)                available.await();            else {                long delay = first.getDelay(NANOSECONDS);                if (delay <= 0)                    return q.poll();                first = null; // don't retain ref while waiting                if (leader != null)                    available.await();                else {                    Thread thisThread = Thread.currentThread();                    leader = thisThread;                    try {                        available.awaitNanos(delay);                    } finally {                        if (leader == thisThread)                            leader = null;                    }                }            }        }    } finally {        if (leader == null && q.peek() != null)            available.signal();        lock.unlock();    }}

SynchronousQueue

　　SynchronousQueue是一个不存储元素的阻塞队列。每一个put操作必须等待一个take操作，否则不能继续添加元素。
　　默认情况下采用非公平策略访问队列。使用以下构造方法可以创建公平性访问的SynchronousQueue，如果设置为true，则等待的线程会采用先进先出的顺序访问队列。

public SynchronousQueue(boolean fair) {    transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();}

　　SynchronousQueue可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素，非常适合于传递性场景,比如在一个线程中使用的数据，传递给另外一个线程使用，SynchronousQueue的吞吐量高于LinkedBlockingQueue 和 ArrayBlockingQueue。

LinkedTransferQueue

　　LinkedTransferQueue是一个由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列LinkedTransferQueue多了tryTransfer和transfer方法。transfer是指入队线程将节点传递给出队线程。
　　transfer方法。如果当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法时），transfer方法可以把生产者传入的元素立刻transfer（传输）给消费者。如果没有消费者在等待接收元素，transfer方法会将元素存放在队列的tail节点，并等到该元素被消费者消费了才返回。transfer方法的关键代码如下：

Node pred = tryAppend(s, haveData);return awaitMatch(s, pred, e, (how == TIMED), nanos);

　　第一行代码是试图把存放当前元素的s节点作为tail节点。第二行代码是让CPU自旋等待消费者消费元素。因为自旋会消耗CPU，所以自旋一定的次数后使用Thread.yield()方法来暂停当前正在执行的线程，并执行其他线程。
　　tryTransfer方法。则是用来试探下生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回false。和transfer方法的区别是tryTransfer方法无论消费者是否接收，方法立即返回。而transfer方法是必须等到消费者消费了才返回。
　　对于带有时间限制的tryTransfer(E e, long timeout, TimeUnit unit)方法，则是试图把生产者传入的元素直接传给消费者，但是如果没有消费者消费该元素则等待指定的时间再返回，如果超时还没消费元素，则返回false，如果在超时时间内消费了元素，则返回true。

LinkedBlockingDeque

　　LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列。所谓双向队列指的你可以从队列的两端插入和移出元素。双端队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。相比其他的阻塞队列，LinkedBlockingDeque多了addFirst，addLast，offerFirst，offerLast，peekFirst，peekLast等方法，以First单词结尾的方法，表示插入，获取（peek）或移除双端队列的第一个元素。以Last单词结尾的方法，表示插入，获取或移除双端队列的最后一个元素。另外插入方法add等同于addLast，移除方法remove等效于removeFirst。但是take方法却等同于takeFirst，不知道是不是Jdk的bug，使用时还是用带有First和Last后缀的方法更清楚。
　　在初始化LinkedBlockingDeque时可以初始化队列的容量，用来防止其再扩容时过渡膨胀。另外双向阻塞队列可以运用在“工作窃取”模式中。