首页 > 代码库 > DelayQueue

DelayQueue

  DelayQueue是一个无界队列,只有在延迟期满的时候,才可以取出元素。该队列的头部存储的延期期满了后保存时间最长的元素。

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

  为了具有调用行为,存放到DelayDeque的元素必须继承Delayed接口。Delayed接口使对象成为延迟对象,它使存放在DelayQueue类中的对象具有了激活日期。

  该接口强制执行下列两个方法。

  CompareTo(Delayed o):Delayed接口继承了Comparable接口,该方法是进行队列中元素的排序。

  getDelay(TimeUnit unit):这个方法返回到激活日期的剩余时间,时间单位由单位参数指定。

  下面给出一个简单的案例,网吧与网民上网,网民交了钱后开始上网,当上网时间到了,网吧结束网民上网。

/**
 * 网民实体类
 */
public class Netizen implements Delayed {
    
    //身份证
    private Long id;
    //姓名
    private String name;
    //上网截至时间
    private Long endTime;
    //定义时间工具类
    private TimeUnit timeUnit = TimeUnit.SECONDS;
    
    public Netizen(Long id, String name, Long endTime) {
        super();
        this.id = id;
        this.name = name;
        this.endTime = endTime;
    }
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Long getEndTime() {
        return endTime;
    }
    public void setEndTime(Long endTime) {
        this.endTime = endTime;
    }
    //元素相互批较排序
    public int compareTo(Delayed o) {
        Netizen netizen=(Netizen) o;
        return this.getDelay(this.timeUnit)-netizen.getDelay(this.timeUnit)>0?1:0;
    }
    //判断是否到了截至时间
    public long getDelay(TimeUnit unit) {
        
        return endTime-System.currentTimeMillis();
    }
}
/**
 * 网吧实体类
 * @author szekinwin
 *
 */
public class InternetBar implements Runnable{
    
    private DelayQueue<Netizen> queue=new DelayQueue<Netizen>();
    
    //网民上网
    public void startComputer(Long id,String name,int money){
        
        Netizen netizen=new Netizen(id, name, 1000*money+System.currentTimeMillis());
        
        System.out.println("网名"+name+"开始上网计费...");
        
        queue.add(netizen);
        
    }
    //网民上网时间结束
    public void overComputer(Netizen netizen){
        
        System.out.println("网名"+netizen.getName()+"上网时间结束...");
        
    }
  //检查上网时间是否到期
public void run() { while(true){ try { Netizen netizen=queue.take(); overComputer(netizen); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[]args){ InternetBar internatBar=new InternetBar();
     //创建三个网民 internatBar.startComputer(
1L, "n1", 3); internatBar.startComputer(2L, "n2", 5); internatBar.startComputer(3L, "n3", 7); Thread t1=new Thread(internatBar); t1.start(); } }

  输出结果如下:

  技术分享

  接下来总结一下PriorityBlockingQueue优先级队列,存放在队列中的元素必须实现Comparable接口,重写compareTo()方法。

public class Task implements Comparable<Task>{

    private int id;
    
    private String name;
    
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int compareTo(Task o) {
        return this.id > o.id?1:(this.id < o.id?-1:0);
    }
    
    public String toString(){
        return this.id + "," + this.name;
    }

}
public class PriorityQueueDemo {
    
    public static void main(String[]args) throws InterruptedException{
        
        PriorityBlockingQueue<Task> queue=new PriorityBlockingQueue<Task>();
        Task t1=new Task();
        t1.setId(5);
        t1.setName("p1");
        Task t2=new Task();
        t2.setId(3);
        t2.setName("p2");
        Task t3=new Task();
        t3.setId(7);
        t3.setName("p3");
        queue.add(t1);
        queue.add(t2);
        queue.add(t3);
        System.out.println(queue.toString());
        System.out.println(queue.take().getId());
    }
}

  输出结果如下:也就是说队列中的元素是根据元素的ID进行排序的。ID值低的优先级高。

  技术分享

  参考网址:http://www.cnblogs.com/wxgblogs/p/5464867.html

DelayQueue