java编程思想笔记-并发之DelayQueue和PriorityBlockingQueue

DelayQueue是无界的BlockingQueue，用于防止实现了Delayed接口的对象，其中的对象只能在其到期时才能从队列中取走，这种队列是有序的且队头对象的延迟到期的时间越长。如果没有任何的延迟到期就不会有头元素，并且poll()将返回null
以下两个示例都是典型的队列元素，生产者，消费者示例

示例:

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>queue=new ArrayList<DelayedTask>();    public DelayedTask(int delayInMilliseconds){        delta=delayInMilliseconds;        trigger=System.nanoTime()+TimeUnit.NANOSECONDS.convert(delta, TimeUnit.MILLISECONDS);        queue.add(this);    }    @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 long getDelay(TimeUnit unit) {        //将时间转换为调用者希望的时间单位        return unit.convert(trigger-System.nanoTime(), TimeUnit.NANOSECONDS);    }    @Override    public void run() {        System.out.println(this+" ");    }    @Override    public String toString() {        return String.format("[%1$-4d]", delta) +                  " Task " + id;    }    public String summary(){        return "("+id+":"+delta+")";    }    public long getTrigger() {        return trigger;    }    //作为延迟队列最后一个执行的任务，并关闭线程池    public static class Endsentinel extends DelayedTask{        private ExecutorService exec;        public Endsentinel(int delayInMilliseconds,ExecutorService exec) {            super(delayInMilliseconds);            this.exec=exec;        }        @Override        public void run(){            for (DelayedTask pt : DelayedTask.queue) {                System.out.println(pt.summary()+" ");            }            System.out.println();            System.out.println(this+" Calling shutdownNow()");            exec.shutdownNow();        }    }}class DelayedTaskConsumer implements Runnable{    private DelayQueue<DelayedTask>queue;    public DelayedTaskConsumer(DelayQueue<DelayedTask> queue){        this.queue=queue;    }    @Override    public void run() {        try {            while (!Thread.interrupted()) {                queue.take().run();            }        } catch (InterruptedException e) {            // TODO: handle exception        }        System.out.println("Finished DelayedTaskConsumer");    }}public class DelayQueueDemo {    public static void main(String[] args) {        Random rand=new Random(47);        ExecutorService exec=Executors.newCachedThreadPool();        DelayQueue<DelayedTask>queue=new DelayQueue<DelayedTask>();        for (int i = 0; i < 20; i++) {            int time=rand.nextInt(5000);            queue.put(new DelayedTask(time));        }        queue.add(new DelayedTask.Endsentinel(5000, exec));        exec.execute(new DelayedTaskConsumer(queue));    }}

PriorityBlockingQueue示例

class PrioritizedTask implements Runnable ,Comparable<PrioritizedTask>{    private Random random=new Random(47);    private static int counter=0;    private final int id=counter++;    private final int priority;    protected static List<PrioritizedTask>sequece=new ArrayList<PrioritizedTask>();    public PrioritizedTask(int priority){        sequece.add(this);        this.priority=priority;    }    @Override    public int compareTo(PrioritizedTask o) {        return priority<o.priority?1:(priority>o.priority?-1:0);    }    @Override    public String toString() {        return String.format("[%1$-3d]", priority)+" Task "+id;    }    public String summary() {        return "("+id+":"+priority+")";    }    @Override    public void run() {        try {            TimeUnit.MILLISECONDS.sleep(random.nextInt(250));        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println(this);    }    public static class EndSentinel extends PrioritizedTask{        private ExecutorService exec;        public EndSentinel(ExecutorService exec) {            super(-1);        }        @Override        public void run(){            int count=0;            for (PrioritizedTask prioritizedTask : PrioritizedTask.sequece) {                System.out.println(prioritizedTask.summary());                if (++count%5==0) {                    System.out.println();                }            }            System.out.println();            System.out.println(this+"Calling shutdownNow()");            exec.shutdownNow();        }    }}//生产者class PrioritizedTaskProducer implements Runnable{    private Random rand=new Random(47);    private Queue<Runnable>queue;    private ExecutorService exec;    public PrioritizedTaskProducer(Queue<Runnable>q,ExecutorService e){        this.queue=q;        this.exec=e;    }    @Override    public void run() {        for (int i = 0; i < 20; i++) {            queue.add(new PrioritizedTask(rand.nextInt(10)));            Thread.yield();        }        try {            //TimeUnit.SECONDS.sleep(1);            for (int i = 0; i < 10; i++) {                TimeUnit.MILLISECONDS.sleep(250);                queue.add(new PrioritizedTask(10));            }            for (int i = 0; i < 10; i++) {                queue.add(new PrioritizedTask(i));            }            queue.add(new PrioritizedTask.EndSentinel(exec));        } catch (InterruptedException e) {            // TODO: handle exception        }        System.out.println("Finshed PrioritizedTask Producer");    }}//消费者class PrioritizedTaskConsumer implements Runnable{    PriorityBlockingQueue<Runnable>q;    public PrioritizedTaskConsumer(PriorityBlockingQueue<Runnable>queue){        this.q=queue;    }    @Override    public void run() {        try {            while (!Thread.interrupted()) {                q.take().run();            }        } catch (InterruptedException e) {        }        System.out.println("Finished PrioritizedTaskConsumer");    }}public class PriorityBlockingQueueTest {    public static void main(String[] args) {        Random rand=new Random(47);        ExecutorService exec=Executors.newCachedThreadPool();        PriorityBlockingQueue<Runnable>queue=new PriorityBlockingQueue<Runnable>();        exec.execute(new PrioritizedTaskProducer(queue, exec));        exec.execute(new PrioritizedTaskConsumer(queue));        System.out.println("done");    }