//用于保证队列操作的线程安全
 private final transient ReentrantLock lock = new ReentrantLock();

 // 优先级队列,存储元素，用于保证延迟低的优先执行
 private final PriorityQueue<E> q = new PriorityQueue<E>();

 // 用于标记当前是否有线程在排队（仅用于取元素时） leader 指向的是第一个从队列获取元素阻塞的线程
 private Thread leader = null;

 // 条件，用于表示现在是否有可取的元素 当新元素到达，或新线程可能需要成为leader时被通知
 private final Condition available = lock.newCondition();

 public DelayQueue() {}
 public DelayQueue(Collection<? extends E> c) {
 this.addAll(c);
 }

入队put方法

    public void put(E e) {
        offer(e);
    }
    public boolean offer(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            // 入队
            q.offer(e);
            if (q.peek() == e) {
                // 若入队的元素位于队列头部，说明当前元素延迟最小
                // 将 leader 置空
                leader = null;
                // available条件队列转同步队列,准备唤醒阻塞在available上的线程
                available.signal();
            }
            return true;
        } finally {
            lock.unlock(); // 解锁，真正唤醒阻塞的线程
        }
    }

出队take方法

 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)// 如果小于0说明已到期，直接调用poll()方法弹出堆顶元素
                         return q.poll();

                     // 如果delay大于0 ，则下面要阻塞了
                     // 将first置为空方便gc
                     first = null;
                     // 如果有线程争抢的Leader线程，则进行无限期等待。
                    if (leader != null)
                        available.await();
                     else {
                         // 如果leader为null，把当前线程赋值给它
                         Thread thisThread = Thread.currentThread();
                         leader = thisThread;
                        try {
                             // 等待剩余等待时间
                             available.awaitNanos(delay);
                             } finally {
                             // 如果leader还是当前线程就把它置为空，让其它线程有机会获取元素
                             if (leader == thisThread)
                                 leader = null;
                             }
                         }
                     }
                 }
             } finally {
             // 成功出队后，如果leader为空且堆顶还有元素，就唤醒下一个等待的线程
             if (leader == null && q.peek() != null)
                // available条件队列转同步队列,准备唤醒阻塞在available上的线程
             available.signal();
             // 解锁，真正唤醒阻塞的线程
             lock.unlock();
             }
         }