并发包中的DelayQueue工具

一、DelayQueue并发工具

无界的BlockingQueue，用于放置实现了Delayed接口的对象，其中的对象只能在其到期时才能从队列中取走。这种队列是有序的，即队头对象的延迟到期的时间最长。如果没有任何延迟到期 ，那么就不会有任何头元素，并且poll()将返回null。（正因为这样，不能将null放置到这种队列中）

---

1.1 代码分析

package myThread;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.*;

import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;

class DelayedTask implements Runnable,Delayed {
    private static int counter=0;
    private final int id=counter++;
    private final int delta; //以毫秒为存储单位
    private final long trigger;
    //保存任务创建的顺序
    protected static List<DelayedTask> sequence =new ArrayList<>();
    public DelayedTask(int delayInMilliseconds){
        delta=delayInMilliseconds;
        //System.nanoTime() 纳秒
        trigger=System.nanoTime()+NANOSECONDS.convert(delta,MILLISECONDS);
        sequence.add(this);
    }
    @Override
    //getDelay(TimeUnit unit)返回与此对象相关的剩余延迟时间，以给定的时间单位表示
    //延迟到期有多长时间
    public long getDelay(TimeUnit unit) {
      //  convert(long duration, TimeUnit unit) 将给定单元的时间段转换到此单元
        return unit.convert(trigger-System.nanoTime(),NANOSECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        DelayedTask that=(DelayedTask) o;
        if(trigger>that.trigger) return -1;
        if(trigger<that.trigger) return 1;
        return 0;
    }

    @Override
    public void run() {
        System.out.println(this+" ");
    }
    public String toString(){
        return String.format("[%1$-4d]",delta)+" Task "+id;
    }
    public String summary(){
        return "("+id+":"+delta+")";
    }
    //内部类
    public static class EndSentinel extends DelayedTask{
        private ExecutorService executorService;
        public EndSentinel(int delayInMilliseconds, ExecutorService executorService) {
            super(delayInMilliseconds);
            this.executorService = executorService;
        }
        public void run(){
            for(DelayedTask delayedTask:sequence){
                System.out.print(delayedTask.summary()+" ");
            }
            System.out.println();
            System.out.println(this+" calling shutdownNow");
            executorService.shutdownNow();
        }
    }
}
class DelayedTaskConsumer implements  Runnable{
    private DelayQueue<DelayedTask> delayedTasks;

    public DelayedTaskConsumer(DelayQueue<DelayedTask> delayedTasks) {
        this.delayedTasks = delayedTasks;
    }

    @Override
    public void run() {
        try{
            while (!Thread.interrupted()){
                delayedTasks.take().run();
            }
        }catch (InterruptedException e){

        }
        System.out.println("Finished DelayedTaskConsumer");
    }
}
public class DelayQueueDemo {
    public static void main(String[] args) {
        Random random = new Random();
        ExecutorService executorService = Executors.newCachedThreadPool();
        DelayQueue<DelayedTask> queue=new DelayQueue<>();
        for (int i = 0; i <20 ; i++) {
            //put  将指定元素添加到此延迟队列中
            queue.put(new DelayedTask(random.nextInt(5000)));
        }
        queue.add(new DelayedTask.EndSentinel(5000,executorService));
        executorService.execute(new DelayedTaskConsumer(queue));
    }

}

输出结果：

(0:548) (1:4224) (2:2090) (3:3748) (4:1518) (5:3604) (6:1094) (7:3385) (8:634) (9:4658) (10:3065) (11:285) (12:1545) (13:799) (14:4378) (15:791) (16:4499) (17:2117) (18:3305) (19:745) (20:5000) 
[5000] Task 20 calling shutdownNow
Finished DelayedTaskConsumer

---

参考

1. 《java编程思想》
2. https://blog.csdn.net/panda_____/article/details/80542361