DelayQueue是一个无界阻塞的队列，队列中的每个元素都有一个过期时间，当要从队列中取出数据时，只有过期元素才会出队。
DelayQueue内部使用PriorityQueue存放元素，又用ReentrantLock实现线程同步。因为DelayQueue内部要获取元素的剩余时间，所以我们的数据类需要继承Delayed接口，Delayed又继承Comparable接口，实现排序，而自身只有一个getDelay()方法，用来获取元素的剩余时间，如果getDelay()返回<=0的值，则表示这个元素过期，通过take()方法即可取出他，如果没有过期值，则take()会一直阻塞。
DelayQueue类涉及到TimeUnit，是在java.util.concurrent包下的一个枚举类，可以非常方便实现时间单位的转化。
//秒转分
System.out.println(TimeUnit.SECONDS.toMinutes(2400));
//分转小时
System.out.println(TimeUnit.MINUTES.toHours(120));
//分转小时
System.out.println(TimeUnit.HOURS.convert(120,TimeUnit.MINUTES));
40
2
2
还可以线程sleep
TimeUnit.MINUTES.sleep(1);
以上就是TimeUnit的一些用法。
在看DelayQueue的简单示例。
首先定义数据类，MyData被实例化后，过期时间是当前时间+转换成毫秒的seconds。在getDelay中返回剩余时间（剩余时间=到期时间-当前时间）。toString()只是方便查看从实例话后到被取出打印花了多长时间。
public class MyData implements Delayed {
private long expire;
private int id;
private long start;
public MyData(int seconds) {
this.expire = System.currentTimeMillis()+TimeUnit.SECONDS.toMillis(seconds);
this.start=System.currentTimeMillis();
this.id = seconds;
}
@Override
public long getDelay(TimeUnit unit) {
long convert = unit.convert(expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
return convert;
}
@Override
public int compareTo(Delayed o) {
return (int)(this.getDelay(TimeUnit.MILLISECONDS)-o.getDelay(TimeUnit.MILLISECONDS));
}
@Override
public String toString() {
return TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()-this.start) +"秒";
}
}
测试类，这里也就是入队5个元素，每个元素从被new出后开始算，当前时间+i秒后相继会过期。
public static void main(String[] args) throws IOException, InterruptedException {
DelayQueue<MyData> queue =new DelayQueue<>();
for (int i = 1; i <=5 ; i++) {
queue.offer(new MyData(i));
}
for (;;){
System.out.println(queue.take());
}
}
输出结果，也正是想要的。
1秒
2秒
3秒
4秒
5秒
offer()
这个方法用来将元素添加到队列，如果元素为null，则抛异常，q是PriorityQueue队列，PriorityQueue会更具自然顺序或Comparator接口进行排序。也就是说下面这段，q.peek方法并不一定是当前添加的元素，如果是当前插入元素，则重置leader线程为null，然后激活avaliable变量条件队列的一个线程，告诉他队列里面有元素了。
public boolean offer(E e) {
//获取到独占锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//向PriorityQueue队列添加数据
q.offer(e);
if (q.peek() == e) {
leader = null;
available.signal();
}
return true;
} finally {
lock.unlock();
}
}
take()
获取并移除队列中过期元素，没有则等待。
首先也是获取独占锁，然后使用peek获取一个元素(peek不移除元素)。
如果first为null，则把当前线程放入available中阻塞等待(available是Condition)。
如果first不为null，则调用这个元素的getDelay获取还有多长时间要过期(参数是NANOSECONDS，纳秒)，如果<=0，则表示已经过期，直接出队返回，否则查看leader是否为null，不为null则说明其他线程也在执行take()，则把线程放入条件队列。如果leader为null，则让leader为当前线程，然后执行等待，剩余过期时间到达后，然后重置leader线程为null，重新进入循环，重新进入后就可以发现队列中的头部元素已经过期，然后返回他。在最后的finally块中，如果判断结果为true，则说明当前线程从队列移除过期元素后，又有其他线程执行了入队，就会调用条件变量的signal方法，激活条件队列里面的等待线程。
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (;;) {
//获取元素
E first = q.peek();
if (first == null)
//等待
available.await();
else {
//获取first元素要过期的时间。
long delay = first.getDelay(NANOSECONDS);
//如果小于等于0，则直接返回
if (delay <= 0)
return q.poll();
first = null;
if (leader != null)
available.await();
else {
//设置leader为当前线程。
Thread thisThread = Thread.currentThread();
leader = thisThread;
try {
//等待
available.awaitNanos(delay);
} finally {
if (leader == thisThread)
leader = null;
}
}
}
}
} finally {
if (leader == null && q.peek() != null)
available.signal();
lock.unlock();
}
}
poll()
获取并移除队头过去元素，如果没有过期元素则返回null。
较简单，只有一个if判断队列是否为空，不为空的话如果队头元素没有过期则返回null。
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
E first = q.peek();
if (first == null || first.getDelay(NANOSECONDS) > 0)
return null;
else
return q.poll();
} finally {
lock.unlock();
}
}
size()
返回队列元素个数
