DelayQueue

是一個無界的BlockingQueue，用於放置實現了Delayed介面的物件，其中的物件只能在其到期時才能從佇列中取走。這種佇列是有序的，即隊頭物件的延遲到期時間最長。注意：不能將null元素放置到這種佇列中。

Delayed

一種混合風格的介面，用來標記那些應該在給定延遲時間之後執行的物件。

此介面的實現必須定義一個 compareTo 方法，該方法提供與此介面的 getDelay 方法一致的排序。

下面的程式碼模擬一個考試的日子，考試時間為120分鐘，30分鐘後才可交卷，當時間到了，或學生都交完捲了者考試結束。執行緒的關閉參考Java程式設計思想中例子，將exec傳給Student的一個內部類，通過他來關閉。

1. package com.woxiaoe.study.thread;  
2. import java.util.Random;  
3. import java.util.concurrent.DelayQueue;  
4. import java.util.concurrent.Delayed;  
5. import java.util.concurrent.ExecutorService;  
6. import java.util.concurrent.Executors;  
7. import java.util.concurrent.TimeUnit;  
8. /** 
9.  * 模擬考試，時間為120分鐘，學生可以再30分鐘後交卷，
    
10.  * 當學生都交完了 或 時間到者考試結束 
11.  * @author 小e 
12.  * 
13.  * 2010-4-30 下午11:14:25 
14.  */  
15. class Student implements Runnable,Delayed{  
16.     private String name;  
17.     private long submitTime;//交卷時間  
18.     private long workTime;//考試時間  
19.     public Student() {  
20.         // TODO Auto-generated constructor stub  
21.     }  
22.     public Student(String name, long
     submitTime) {  
23.         super();  
24.         this.name = name;  
25.         workTime = submitTime;  
26.         //都轉為轉為ns  
27.         this.submitTime = TimeUnit.NANOSECONDS.convert(submitTime, TimeUnit.MILLISECONDS) + System.nanoTime();  
28.     }  
29.     @Override  
30.     public void run() {  
31.         System.out.println(name + " 交卷,用時" + workTime/100 + "分鐘");  
32.     }  
33.     @Override  
34.     public long getDelay(TimeUnit unit) {  
35.         return unit.convert(submitTime - System.nanoTime(), unit.NANOSECONDS);  
36.     }  
37.     @Override  
38.     public int compareTo(Delayed o) {  
39.         Student that = (Student) o;  
40.         return submitTime > that.submitTime?1:(submitTime < that.submitTime ? -1 : 0);  
41.     }  
42.     public static class EndExam extends Student{  
43.         private ExecutorService exec;  
44.         public EndExam(int submitTime,ExecutorService exec) {  
45.             super(null,submitTime);  
46.             this.exec = exec;  
47.         }  
48.         @Override  
49.         public void run() {  
50.             exec.shutdownNow();  
51.         }  
52.     }  
53. }  
54. class Teacher implements Runnable{  
55.     private DelayQueue<Student> students;  
56.     private ExecutorService exec;  
57.     public Teacher(DelayQueue<Student> students,ExecutorService exec) {  
58.         super();  
59.         this.students = students;  
60.         this.exec = exec;  
61.     }  
62.     @Override  
63.     public void run() {  
64.         try {  
65.             System.out.println("考試開始……");  
66.             while (!Thread.interrupted()) {  
67.                 students.take().run();  
68.             }  
69.             System.out.println("考試結束……");  
70.         } catch (InterruptedException e) {  
71.             e.printStackTrace();  
72.         }  
73.     }  
74. }  
75. public class Exam {  
76.     static final int STUDENT_SIZE = 45;  
77.     public static void main(String[] args) {  
78.         Random r = new Random();  
79.         DelayQueue<Student> students = new DelayQueue<Student>();  
80.         ExecutorService exec = Executors.newCachedThreadPool();  
81.         for(int i = 0; i < STUDENT_SIZE; i++){  
82.             students.put(new Student("學生" + ( i + 1), 3000 + r.nextInt(9000)));  
83.         }  
84.         students.put(new Student.EndExam(12000,exec));//1200為考試結束時間  
85.         exec.execute(new Teacher(students, exec));  
86.     }  
87. }