画个JUC阻塞队列的类关系图，之前都没在意，画一下感觉会清楚很多
DelayQueue是无界的阻塞队列，其特点是实现队列元素的延迟出队，通俗点说就是队列元素可以设置延迟时间，时间不到，就待在队列中，很有意思的东西，感觉跟redis设置过期时间一样。队列元素不容许添加null元素。DelayQueue可以用来实现调度的定时任务或者缓存的过期。
添加的队列元素必须实现Delayed接口：
//实现Delayed接口的类也必须实现Comparable接口
public interface Delayed extends Comparable<Delayed> {
/**
* 获取剩余延迟时间，注意这里的传入的时间单位，getDelay返回的时间要做转换
*/
long getDelay(TimeUnit unit);
}实现类必须同时实现Delayed和Comparable接口。
看下内部结构和构造：
private transient final ReentrantLock lock = new ReentrantLock();
//内部使用PriorityQueue存储数据
private final PriorityQueue<E> q = new PriorityQueue<E>();
/**
* Thread designated to wait for the element at the head of
* the queue. This variant of the Leader-Follower pattern
* (http://www.cs.wustl.edu/~schmidt/POSA/POSA2/) serves to
* minimize unnecessary timed waiting. When a thread becomes
* the leader, it waits only for the next delay to elapse, but
* other threads await indefinitely. The leader thread must
* signal some other thread before returning from take() or
* poll(...), unless some other thread becomes leader in the
* interim. Whenever the head of the queue is replaced with
* an element with an earlier expiration time, the leader
* field is invalidated by being reset to null, and some
* waiting thread, but not necessarily the current leader, is
* signalled. So waiting threads must be prepared to acquire
* and lose leadership while waiting.
*/
private Thread leader = null;
/**
* Condition signalled when a newer element becomes available
* at the head of the queue or a new thread may need to
* become leader.
*/
private final Condition available = lock.newCondition();
/**
* 默认空构造
*/
public DelayQueue() {}使用PriorityQueue存储元素，leader的用法有点ReetrantLock的独占锁的意思。
添加元素的方法：
public boolean add(E e) {
return offer(e);
}
/**
* 添加元素
*/
public boolean offer(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
q.offer(e);
if (q.peek() == e) { //添加元素后peek还是e，重置leader，通知条件队列
leader = null;
available.signal();
}
return true;
} finally {
lock.unlock();
}
}
public void put(E e) {
offer(e);
}
/**
* 超时时间没有，无界，肯定成功
*/
public boolean offer(E e, long timeout, TimeUnit unit) {
return offer(e);
}最后都是调动offer，带超时的offer，超时时间不起作用，因为是无界的，不会产生阻塞，所以超时没有意思。
看下获取poll\take\peek:
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
E first = q.peek();
if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0) //队列为空或者延迟时间未过期
return null;
else
return q.poll();
} 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(TimeUnit.NANOSECONDS); //获取剩余延迟时间
if (delay <= 0) //小于0，那就poll元素
return q.poll();
else if (leader != null) //有延迟，检查leader，不为空说明有其他线程在等待，那就加入条件队列
available.await();
else {
Thread thisThread = Thread.currentThread();
leader = thisThread; //设置当前为leader等待
try {
available.awaitNanos(delay); //条件队列等待指定时间
} finally {
if (leader == thisThread) //检查是否被其他线程改变，没有就重置，再次循环
leader = null;
}
}
}
}
} finally {
if (leader == null && q.peek() != null) //leader为空并且队列不空，说明没有其他线程在等待，那就通知条件队列
available.signal();
lock.unlock();
}
}
/**
* 响应超时的poll
*/
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(TimeUnit.NANOSECONDS);
if (delay <= 0)
return q.poll();
if (nanos <= 0)
return null;
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();
}
}
/**
* 获取queue[0]，peek是不移除的
*/
public E peek() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.peek();
} finally {
lock.unlock();
}
}不带阻塞的poll，直接peek元素，判断非空并且延迟时间未到，那就return null，到了那就poll。take()方法考虑的就比较多：1.队列为空，阻塞；2.不空就看延迟时间，到了就poll，没到就看有没有其他线程已经占用等待了，有就阻塞，没有就自己占用leader，然后wait。
DelayedQueue其他方法不看了，理解offer和take就OK了。