并发-新类库中的构件 DelayQueue

DelayQueue

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

package com21concurrent;

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;

/**
 * Created by Panda on 2018/6/1.
 */
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;
        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:3392) (1:4055) (2:3060) (3:1415) (4:4503) (5:3145) (6:2459) (7:153) (8:1336) (9:2699) (10:942) (11:2323) (12:2829) (13:1663) (14:1409) (15:375) (16:2797) (17:2087) (18:4921) (19:2271) (20:5000)
     [5000] Task 20 calling shutdownNow
     Finished DelayedTaskConsumer
     */
}

从输出中可以看到，任务创建的顺序对执行顺序没有任何影响，任务时按照所期望的延迟顺序执行的。