同步辅助类-DelayQueue队列研究

 * An unbounded {@linkplain BlockingQueue blocking queue} of
 * <tt>Delayed</tt> elements, in which an element can only be taken
 * when its delay has expired.  The <em>head</em> of the queue is that
 * <tt>Delayed</tt> element whose delay expired furthest in the
 * past.  If no delay has expired there is no head and <tt>poll</tt>
 * will return <tt>null</tt>. Expiration occurs when an element's
 * <tt>getDelay(TimeUnit.NANOSECONDS)</tt> method returns a value less
 * than or equal to zero.  Even though unexpired elements cannot be
 * removed using <tt>take</tt> or <tt>poll</tt>, they are otherwise
 * treated as normal elements. For example, the <tt>size</tt> method
 * returns the count of both expired and unexpired elements.
 * This queue does not permit null elements.

从源码的介绍中我们可知：是一个无界的BlockingQueue，用于放置实现了Delayed接口的对象，其中的对象只能在其到期时才能从队列中取走。这种队列是有序的，即队头对象的延迟到期时间最长。如果所有的对象都被取走，那么将会返回一个null。当对象的getDelay()方法返回一个小于等于0的值，对象的延迟时间就到了。尽管延迟时间未到的对象不能从队列中取出，但他们仍然当作普通的对象来对待，比如队列的size()方法返回的是延迟时间到期和延迟时间未到期的对象个数之和。

注意：不能将null元素放置到这种队列中。

2 Delay

 * A mix-in style interface for marking objects that should be
 * acted upon after a given delay.
 *
 * <p>An implementation of this interface must define a
 * <tt>compareTo</tt> method that provides an ordering consistent with
 * its <tt>getDelay</tt> method.

一种混合风格的接口，用来标记那些应该在给定延迟时间之后执行的对象。

此接口的实现必须定义一个 compareTo 方法，该方法提供与此接口的 getDelay 方法一致的排序。

DelayQueue队列中保存的是实现了Delayed接口的实现类，里面必须实现getDelay()和compareTo()方法，前者用于取DelayQueue里面的元素时判断是否到了延时时间，否则不予获取，是则获取。  compareTo()方法用于进行队列内部的排序

4.example示例

 

Student类:用于实现delayed接口的对象，继承并实现二个方法

[java]  view plain copy

1. package org.taobao.terminator.client.fww;  
2. import java.util.concurrent.Delayed;  
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.TimeUnit;  
5. class Student implements Runnable,Delayed{    
6.     private String name;    
7.     private long submitTime;//交卷时间    
8.     private long workTime;//考试时间    
9.     public Student() {    
10.               
11.     }    
12.     public Student(String name, long submitTime) {    
13.         super();    
14.         this.name = name;    
15.         workTime = submitTime;    
16.         //都转为转为ns    
17.         this.submitTime = TimeUnit.NANOSECONDS.convert(submitTime, TimeUnit.MILLISECONDS) + System.nanoTime();    
18.     }    
19.     
20.     @Override    
21.     public void run() {    
22.         System.out.println(name + " 交卷,用时" + workTime/100 + "分钟");    
23.     }    
24.     
25.     @Override    
26.     public long getDelay(TimeUnit unit) {    
27.         return unit.convert(submitTime - System.nanoTime(), unit.NANOSECONDS);    
28.     }    
29.     
30.     @Override    
31.     public int compareTo(Delayed o) {    
32.         Student that = (Student) o;    
33.         return submitTime > that.submitTime?1:(submitTime < that.submitTime ? -1 : 0);    
34.     }    
35.     public static class EndExam extends Student{    
36.         private ExecutorService exec;    
37.         public EndExam(int submitTime,ExecutorService exec) {    
38.             super(null,submitTime);    
39.             this.exec = exec;    
40.         }    
41.         @Override    
42.         public void run() {    
43.             exec.shutdownNow();    
44.         }    
45.     }    
46.         
47. }    

 

 

Teacher类：辅助类

[java]  view plain copy

1. package org.taobao.terminator.client.fww;  
2. import java.util.concurrent.DelayQueue;  
3. import java.util.concurrent.ExecutorService;  
4. class Teacher implements Runnable{    
5.     private DelayQueue<Student> students;    
6.     private ExecutorService exec;    
7.         
8.     public Teacher(DelayQueue<Student> students,ExecutorService exec) {    
9.         super();    
10.         this.students = students;    
11.         this.exec = exec;    
12.     }    
13.     
14.     
15.     @Override    
16.     public void run() {    
17.         try {    
18.             System.out.println("考试开始……");    
19.             while (!Thread.interrupted()) {    
20.                 students.take().run();    
21.             }    
22.             System.out.println("考试结束……");    
23.         } catch (InterruptedException e) {    
24.             e.printStackTrace();    
25.         }    
26.     
27.     }    
28.         
29. }    

 

 

 

 

Exam类：执行测试类

[java]  view plain copy

1. package org.taobao.terminator.client.fww;  
2. import java.util.Random;  
3. import java.util.concurrent.DelayQueue;  
4. import java.util.concurrent.ExecutorService;  
5. import java.util.concurrent.Executors;  
6. public class Exam {    
7.     static final int STUDENT_SIZE = 45;    
8.     public static void main(String[] args) {    
9.         Random r = new Random();    
10.         DelayQueue<Student> students = new DelayQueue<Student>();    
11.         ExecutorService exec = Executors.newCachedThreadPool();    
12.         for(int i = 0; i < STUDENT_SIZE; i++){    
13.             students.put(new Student("学生" + ( i + 1), 3000 + r.nextInt(9000)));    
14.         }    
15.         students.put(new Student.EndExam(12000,exec));//1200为考试结束时间    
16.         exec.execute(new Teacher(students, exec));    
17.             
18.     }    
19.     
20. }