public interface Delayed extends Comparable<Delayed> {
 
    /**
     * 返回與此對象相關(guān)的剩余延遲時(shí)間，以給定的時(shí)間單位表示
     */
    long getDelay(TimeUnit unit);
}

  private final transient ReentrantLock lock = new ReentrantLock();
    private final PriorityQueue<E> q = new PriorityQueue<E>();
 
    /**
    *用于優(yōu)化內(nèi)部阻塞通知的線程
     */
    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);
            //如果插入元素是第一個(gè)元素
            if (q.peek() == e) {
                //leader設(shè)置為null
                leader = null;
                //喚醒
                available.signal();
            }
            return true;
        } finally {
            lock.unlock();
        }
    }
    public boolean offer(E e, long timeout, TimeUnit unit) {
        return offer(e);
    }
    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            E first = q.peek();
            //如果未到期，則返回null，否則刪除
            if (first == null || first.getDelay(NANOSECONDS) > 0)
                return null;
            else
                return q.poll();
        } finally {
            lock.unlock();
        }
    }
   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);
                    //到期，則poll
                    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<delay，表示超時(shí)剩余時(shí)間小于到期時(shí)間，
                        nanos = available.awaitNanos(nanos);
                    else {
                        Thread thisThread = Thread.currentThread();
                        //設(shè)置當(dāng)前線程為leader
                        leader = thisThread;
                        try {
                            //等待條件
                            long timeLeft = available.awaitNanos(delay);
                            //剩余超時(shí)時(shí)間
                            nanos -= delay - timeLeft;
                        } finally {
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
            if (leader == null && q.peek() != null)
                available.signal();
            lock.unlock();
        }
    }
    public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return q.peek();
        } finally {
            lock.unlock();
        }
    }

/**
     * Retrieves and removes the head of this queue, waiting if necessary
     * until an element with an expired delay is available on this queue.
     *
     * @return the head of this queue
     * @throws InterruptedException {@inheritDoc}
     */
    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        // 獲取可中斷鎖。
        lock.lockInterruptibly();
        try {
            for (;;) {
                // 從優(yōu)先級隊(duì)列中獲取隊(duì)列頭元素
                E first = q.peek();
                if (first == null)
                    // 無元素，當(dāng)前線程加入等待隊(duì)列，并阻塞
                    available.await();
                else {
                    // 通過getDelay 方法獲取延遲時(shí)間
                    long delay = first.getDelay(NANOSECONDS);
                    if (delay <= 0)
                        // 延遲時(shí)間到期，獲取并刪除頭部元素。
                        return q.poll();
                    first = null; // don't retain ref while waiting
                    if (leader != null)
                        available.await();
                    else {
                        Thread thisThread = Thread.currentThread();
                        leader = thisThread;
                        try {
                            // 線程節(jié)點(diǎn)進(jìn)入等待隊(duì)列 x 納秒。
                            available.awaitNanos(delay);
                        } finally {
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
            // leader == null且還存在元素的話，喚醒一個(gè)消費(fèi)線程。
            if (leader == null && q.peek() != null)
                available.signal();
            lock.unlock();
        }
    }
   public void put(E e) {
        offer(e);
    }