DelayQueue

概述

DelayQueue是一个无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的Delayed 元素。

DelayQueue阻塞队列在我们系统开发中也常常会用到，例如：缓存系统的设计，缓存中的对象，超过了空闲时间，需要从缓存中移出；任务调度系统，能够准确的把握任务的执行时间。我们可能需要通过线程处理很多时间上要求很严格的数据，如果使用普通的线程，我们就需要遍历所有的对象，一个一个的检 查看数据是否过期等，首先这样在执行上的效率不会太高，其次就是这种设计的风格也大大的影响了数据的精度。一个需要12:00点执行的任务可能12:01 才执行,这样对数据要求很高的系统有更大的弊端。由此我们可以使用DelayQueue。

　　为了具有调用行为，存放到DelayDeque的元素必须继承Delayed接口。Delayed接口使对象成为延迟对象，它使存放在DelayQueue类中的对象具有了激活日期。该接口强制执行下列两个方法。

• CompareTo(Delayed o)：Delayed接口继承了Comparable接口，因此有了这个方法。
• getDelay(TimeUnit unit):这个方法返回到激活日期的剩余时间，时间单位由单位参数指定。

 

Delayed，一种混合风格的接口，用来标记那些应该在给定延迟时间之后执行的对象。此接口的实现必须定义一个 compareTo 方法，该方法提供与此接口的 getDelay 方法一致的排序。

简单的延时队列要有三部分：第一实现了Delayed接口的消息体、第二消费消息的消费者、第三存放消息的延时队列

 

public class DelayQueueTest {

	static class Message implements Delayed
	{
		private int id;  
	    private String body; // 消息内容  
	    private long excuteTime;// 延迟时长，这个是必须的属性因为要按照这个判断延时时长。  
	  
	    public int getId() {  
	        return id;  
	    }  
	  
	    public String getBody() {  
	        return body;  
	    }  
	  
	    public long getExcuteTime() {  
	        return excuteTime;  
	    }  
	  
	    public Message(int id, String body, long delayTime) {  
	        this.id = id;  
	        this.body = body;  
	        this.excuteTime = TimeUnit.NANOSECONDS.convert(delayTime, TimeUnit.MILLISECONDS) + System.nanoTime();  
	    }  
	  
	    // 自定义实现比较方法返回 1 0 -1三个参数  
	    @Override  
	    public int compareTo(Delayed delayed) {  
	        Message msg = (Message) delayed;  
	        return Integer.valueOf(this.id) > Integer.valueOf(msg.id) ? 1  
	                : (Integer.valueOf(this.id) < Integer.valueOf(msg.id) ? -1 : 0);  
	    }  
	  
	    // 延迟任务是否到时就是按照这个方法判断如果返回的是负数则说明到期否则还没到期  
	    @Override  
	    public long getDelay(TimeUnit unit) {  
	        return unit.convert(this.excuteTime - System.nanoTime(), TimeUnit.NANOSECONDS);  
	    }  
	}
	
	
	public static class Consumer implements Runnable {  
	    // 延时队列 ,消费者从其中获取消息进行消费  
	    private DelayQueue<Message> queue;  
	  
	    public Consumer(DelayQueue<Message> queue) {  
	        this.queue = queue;  
	    }  
	  
	    @Override  
	    public void run() {  
	        while (true) {  
	            try {  
	                Message take = queue.take();  
	                System.out.println("消费消息id：" + take.getId() + " 消息体：" + take.getBody());  
	            } catch (InterruptedException e) {  
	                e.printStackTrace();  
	            }  
	        }  
	    }  
	}  
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		 // 创建延时队列    
        DelayQueue<Message> queue = new DelayQueue<Message>();    
        // 添加延时消息,m1 延时3s    
        Message m1 = new Message(1, "world", 3000);    
        // 添加延时消息,m2 延时10s    
        Message m2 = new Message(2, "hello", 10000);    
        //将延时消息放到延时队列中  
        queue.offer(m2);    
        queue.offer(m1);    
        // 启动消费线程 消费添加到延时队列中的消息，前提是任务到了延期时间   
        ExecutorService exec = Executors.newFixedThreadPool(1);  
        exec.execute(new Consumer(queue));  
        exec.shutdown();
        
	}

}

实现

DelayQueue是基于PriorityQueue来实现的。

public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
    implements BlockingQueue<E> {

    private final transient ReentrantLock lock = new ReentrantLock();
    private final PriorityQueue<E> q = new PriorityQueue<E>();
...
}

 

只会返回过期的元素

    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();
        }
    }



    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; // don't retain ref while waiting
                    if (leader != null)
                        available.await();
                    else {
                        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();
        }
    }