DelayQueue

       DelayQueue是一种延迟队列，它所管理的对象必须实现java.util.concurrent.Delayed接口，该接口提供了一个getDelay方法，用于获取剩余的延迟时间，同时该接口继承自Comparable，其compareTo的实现体一般用于比较延迟时间的大小。

       DelayQueue是阻塞的优先级队列，其线程安全由重入锁ReentrantLock实现，而优先级特性则完全有内部PriorityQueue来提供。

       java延迟队列提供了在指定时间才能获取队列元素的功能，队列头元素是最接近过期的元素。没有过期元素的话，使用poll()方法会返回null值，超时判定是通过getDelay(TimeUnit.NANOSECONDS)方法的返回值小于等于0来判断。延时队列不能存放空元素。

1，成员变量

//重入锁
private final transient ReentrantLock lock = new ReentrantLock();
//优先级队列，DelayQueue的数据容器
private final PriorityQueue<E> q = new PriorityQueue<E>();
//正在执行take的线程，领头线程
private Thread leader = null;
//条件监视器，用于阻塞当前线程
private final Condition available = lock.newCondition();

2，add/offer方法 

       add和offer方法都是入队方法，因为add(E)把实现直接委托给了offer。

public boolean offer(E e) {
    final ReentrantLock lock = this.lock;
    //上锁，保证代码块的线程安全
    lock.lock();
    try {
        //把数据放入队列
        q.offer(e);
        //如果新入队的这个元素被排到堆顶
        if(1.peek() == e) {
            //如果有poll和take函数正在等待，那么唤醒之，并清空领头线程
            ledader == null;
            available.signal();
        }
        return true;
    } finally {
        lock.unlock();
    }
}

       offer方法的整体思路很清晰，通过利用PriorityQueue的offer方法，来达到等待时间越短的元素越靠近堆顶的目的。 

       但是，唤醒其他队列是什么含义呢？

当堆为空的时候，如果之前有线程执行过take()，那么线程会一直阻塞。新入队的元素e一定满足q.peek() == e,此时需要唤醒正在等待的leader线程。

       当堆不为空的时候，q.peek() == e，则说明堆内没有等待时间比e更短的元素，如果之前其他线程执行过take()，那么线程同样也会阻塞，并且期望去除元素e，所以也许需要唤醒leader线程，使之重新获取堆顶元素。

       为什么唤醒的一定是leader线程呢？因为leader线程一定是最先调用到的await的，所以也会第一个被唤醒，而leader==null这个判断在take方法里构成了一个自旋锁，只有满足该条件，才能重置leader为当前线程。

3，poll/peek方法

       poll/peek方法用于阻塞地取出堆顶元素：

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 peek() {
    final ReentrantLock lock = this.lock();
    lock.lock();
    try {
        return q.peek();
    } finally {
        lock.unlock();
    }
}

4，take方法 

       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) {
                    return q.poll();
                }
                first = null;
                //如果已经存在了领头线程，那么需要等待领头线程完成操作
                if(leader != null) {
                    available.await();
                } else {
                    //没有领头线程存在的时候，当前线程即为领头线程，等待剩余的超时时长
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        available.awaitNanos(delay);
                    } finally {
                        //如果当前线程是领头线程，那么认为任务完成，清空领头线程
                        if(leader == thisThread) {
                            leader = null;
                        }
                    }
                }
            }
        }
    } finally {
        //leader == null 说明有下一个线程在等待，q.peek() != null说明队列里有数据
        //通知下一个出队的线程执行过
        if(leader == null && q.peek() != null) {
            available.signal();
        }
        lock.unlock();
    }
}

5，举例 

每5秒取出一个

public class DelayedQueneTest {

    public static void main(String[] args) throws InterruptedException {
        Item item1 = new Item("item1", 5, TimeUnit.SECONDS);
        Item item2 = new Item("item2",10, TimeUnit.SECONDS);
        Item item3 = new Item("item3",15, TimeUnit.SECONDS);
        DelayQueue<Item> queue = new DelayQueue<>();
        queue.put(item1);
        queue.put(item2);
        queue.put(item3);
        System.out.println("begin time:" + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
        for (int i = 0; i < 3; i++) {
            Item take = queue.take();
            System.out.format("name:{%s}, time:{%s}\n",take.name, LocalDateTime.now().format(DateTimeFormatter.ISO_DATE_TIME));
        }
    }

}

class Item implements Delayed{
    /* 触发时间*/
    private long time;
    String name;

    public Item(String name, long time, TimeUnit unit) {
        this.name = name;
        this.time = System.currentTimeMillis() + (time > 0? unit.toMillis(time): 0);
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return time - System.currentTimeMillis();
    }

    @Override
    public int compareTo(Delayed o) {
        Item item = (Item) o;
        long diff = this.time - item.time;
        if (diff <= 0) {// 改成>=会造成问题
            return -1;
        }else {
            return 1;
        }
    }

    @Override
    public String toString() {
        return "Item{" +
                "time=" + time +
                ", name='" + name + '\'' +
                '}';
    }
}