java并发容器——延迟队列DelayQueue

延时阻塞队列DelayQueue是一种特殊的优先级队列，它也是无界的，它要求每个元素都实现Delayed接口，该接口的声明为：

public interface Delayed extends Comparable<Delayed> {
    long getDelay(TimeUnit unit);
}

Delayed扩展了Comparable接口，也就是说，DelayQueue的每个元素都是可比较的，它有一个额外方法getDelay返回一个给定时间单位unit的整数，表示再延迟多长时间，如果小于等于0，表示不再延迟。

DelayQueue也是优先级队列，它按元素的延时时间出队，它的特殊之处在于，只有当元素的延时过期之后才能被从队列中拿走，也就是说，take方法总是返回第一个过期的元素，如果没有，则阻塞等待。

DelayQueue可以用于实现定时任务，我们看段简单的示例代码：

public class DelayedQueueDemo {
    private static final AtomicLong taskSequencer = new AtomicLong(0);

    static class DelayedTask implements Delayed {
        private long runTime;
        private long sequence;
        private Runnable task;

        public DelayedTask(int delayedSeconds, Runnable task) {
            this.runTime = System.currentTimeMillis() + delayedSeconds * 1000;
            this.sequence = taskSequencer.getAndIncrement();
            this.task = task;
        }

        @Override
        public int compareTo(Delayed o) {
            if (o == this) {
                return 0;
            }
            if (o instanceof DelayedTask) {
                DelayedTask other = (DelayedTask) o;
                if (runTime < other.runTime) {
                    return -1;
                } else if (runTime > other.runTime) {
                    return 1;
                } else if (sequence < other.sequence) {
                    return -1;
                } else {
                    return 1;
                }
            }
            throw new IllegalArgumentException();
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(runTime - System.currentTimeMillis(),
                    TimeUnit.MICROSECONDS);
        }

        public Runnable getTask() {
            return task;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        DelayQueue<DelayedTask> tasks = new DelayQueue<>();
        tasks.put(new DelayedTask(2, new Runnable() {
            @Override
            public void run() {
                System.out.println("execute delayed task");
            }
        }));

        DelayedTask task = tasks.take();
        task.getTask().run();
    }
}

DelayedTask表示延时任务，只有延时过期后任务才会执行，任务按延时时间排序，延时一样的按照入队顺序排序。

内部，DelayQueue是基于PriorityQueue实现的，它使用一个锁ReentrantLock保护所有访问，使用一个条件available表示头部是否有元素，当头部元素的延时未到时，take操作会根据延时计算需睡眠的时间，然后睡眠，如果在此过程中有新的元素入队，且成为头部元素，则阻塞睡眠的线程会被提前唤醒然后重新检查。以上是基本思路，DelayQueue的实现有一些优化，以减少不必要的唤醒，具体我们就不探讨了。

模拟一个考试的日子，考试时间为120分钟，30分钟后才可交卷，当时间到了，或学生都交完卷了考试结束。

这个场景中几个点需要注意：

1. 考试时间为120分钟，30分钟后才可交卷，初始化考生完成试卷时间最小应为30分钟
2. 对于能够在120分钟内交卷的考生，如何实现这些考生交卷
3. 对于120分钟内没有完成考试的考生，在120分钟考试时间到后需要让他们强制交卷
4. 在所有的考生都交完卷后，需要将控制线程关闭

抽象出两个类，学生类和老师类，用DelayQueue存储考生（Student类）。每一个考生都有自己的名字和完成试卷的时间

Teacher线程对DelayQueue进行监控，收取完成试卷小于120分钟的学生的试卷。当考试时间120分钟到时，teacher线程宣布考试结束，强制DelayQueue中还存在的考生交卷。

package   zhongqiu.common.base.thread;

import   java.util.Iterator;
import   java.util.Random;
import   java.util.concurrent.DelayQueue;
import   java.util.concurrent.Delayed;
import   java.util.concurrent.TimeUnit;

public   class   DelayQueueDemoOne {

    public   static   void   main(String[] args)  throws   InterruptedException {
        // TODO Auto-generated method stub
        int   studentNumber =  20 ;
        DelayQueue<Student> students =  new   DelayQueue<Student>();
        Random random =  new   Random();
        for   ( int   i =  0 ; i < studentNumber; i++) {
            students.put( new   Student( "student"   + (i +  1 ),  30   + random.nextInt( 120 )));
        }
        students.put( new   Student( "student" , 120 ));
        Thread teacherThread =  new   Thread( new   Teacher(students));
        teacherThread.start();
    }
}

class   Student  implements   Runnable, Delayed {

    private   String name;
    public   long   workTime;
    private   long   submitTime;
    private   boolean   isForce =  false ;

    public   Student() {
    }

    public   Student(String name,  long   workTime) {
        this .name = name;
        this .workTime = workTime;
        this .submitTime = TimeUnit.NANOSECONDS.convert(workTime, TimeUnit.NANOSECONDS) + System.nanoTime(); // 纳秒级别
    }

    @Override
    public   int   compareTo(Delayed o) {
        // TODO Auto-generated method stub
        if   (o ==  null   || !(o  instanceof   Student))
            return   1 ;
        if   (o ==  this )
            return   0 ;
        Student s = (Student) o;
        if   ( this .workTime > s.workTime) {
            return   1 ;
        }  else   if   ( this .workTime == s.workTime) {
            return   0 ;
        }  else   {
            return   - 1 ;
        }
    }

    @Override
    public   long   getDelay(TimeUnit unit) {
        // TODO Auto-generated method stub
        return   unit.convert(submitTime - System.nanoTime(), TimeUnit.NANOSECONDS);
    }

    @Override
    public   void   run() {
        // TODO Auto-generated method stub
        if   (isForce) {
            System.out.println(name +  " 交卷，实际用时 120分钟" );
        }  else   {
            System.out.println(name +  " 交卷,"   +  "实际用时 "   + workTime +  " 分钟" );
        }
    }

    public   boolean   isForce() {
        return   isForce;
    }

    public   void   setForce( boolean   isForce) {
        this .isForce = isForce;
    }

}

class   Teacher  implements   Runnable {
    private   int   counter =  20 ;
    private   DelayQueue<Student> students;

    public   Teacher(DelayQueue<Student> students) {
        this .students = students;
    }

    @Override
    public   void   run() {
        // TODO Auto-generated method stub
        try   {
            System.out.println( " test start" );
            while   (counter >  0 ) {
                Student student = students.poll();
                if   (student.workTime< 120 ) {
                    student.run();
                    if   (counter >  0 ) {
                        counter--;
                    }
                }  else   {
                    System.out.println( " 考试时间到，全部交卷！" );
                    Student tmpStudent;
                    for   (Iterator<Student> iterator2 = students.iterator(); iterator2.hasNext();) {
                        tmpStudent = iterator2.next();
                        tmpStudent.setForce( true );
                        tmpStudent.run();
                        if   (counter >  0 ) {
                            counter--;
                        }
                    }
                }
            }
        }  catch   (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }

}