DelayedQueue源码分析

概述

存放具有过期时间的元素的无界阻塞队列，队列中的元素只有在到达指定过期时间时才能从队列中取出。队列中的head节点的过期时间最长。如果没有元素到达过期时间，则没有head节点，poll方法会返回null。判断一个元素是否过期，是通过调用元素的getDelay(TimeUnit.NANOSECONDS)，如果方法的返回值小于等于0，则该元素过期。未过期的元素无法通过调用take方法或poll方法进行删除，而调用size方法会返回过期和未过期元素的总数量。同大多数并发集合一样，该队列不允许null值。

成员变量

private final transient ReentrantLock lock = new ReentrantLock();
private final PriorityQueue<E> q = new PriorityQueue<E>();
//用于等待队列的head节点的元素的线程
private Thread leader = null;
//当队列中的head节点的新元素变为可用时，进行条件唤醒
private final Condition available = lock.newCondition();

poll方法

/**
     * Retrieves and removes the head of this queue, waiting if necessary
     * until an element with an expired delay is available on this queue,
     * or the specified wait time expires.
     *
     * @return the head of this queue, or {@code null} if the
     *         specified waiting time elapses before an element with
     *         an expired delay becomes available
     * @throws InterruptedException {@inheritDoc}
     */
    public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            for (;;) {
                E first = q.peek();
                if (first == null) {
                    if (nanos <= 0)
                        return null;
                    else
                        nanos = available.awaitNanos(nanos);
                } else {
                    long delay = first.getDelay(NANOSECONDS);
                    if (delay <= 0)
                        return q.poll();
                    if (nanos <= 0)
                        return null;
                    first = null; // don't retain ref while waiting
                    if (nanos < delay || leader != null)
                        nanos = available.awaitNanos(nanos);
                    else {
                        Thread thisThread = Thread.currentThread();
                        leader = thisThread;
                        try {
                            long timeLeft = available.awaitNanos(delay);
                            nanos -= delay - timeLeft;
                        } finally {
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
            if (leader == null && q.peek() != null)
                available.signal();
            lock.unlock();
        }
    }