import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * DelayQueue
 * 
 * 這是一個無界的BlockingQueue，用於放置實現了Delayed介面的物件，
 * 其中的物件只能在其到時才能從佇列中取走。這種佇列是有序的，即隊頭物件的延遲到期的時間最長。
 * 如果沒有任何延遲到期，那麼就不會有任何頭元素，並且poll()將返回null（正因為這樣，你不能將
 * null放置到這種佇列中）。
 * 
 * 下面是一個示例，其中的Delayed物件自身就是任務，而DelayedTaskConsumer將最“緊急”的任務
 * （到期時間最長的任務）從佇列中取出，然後執行它。注意，這樣DelayQueue就成為了優先順序佇列的一種變體：
 */
/**
 * DelayedTask包含一個稱為sequence的List<DelayedTask>，它儲存了任務被建立的順序，因此我們可以看到
 * 排序是按照實際發生的順序執行的。
 * 
 * Delayed介面有一個方法名為getDelay()，它可以用來告知延遲到期有多長時間，或者延遲在多長時間之前已經到期。
 * 這個方法將強制我們去使用TimeUnit類，因此這就是引數型別。這會產生一個非常方便的類，因為你可以很容易地
 * 轉換單位而無需任何宣告。例如，delta的值時以毫秒為單位儲存的，但是java SE5的方法System.nanoTime()產生
 * 的時間則是以納米為單位的。你可以轉換delta的值，這個方法是宣告它的單位以及你希望以什麼單位來表示，
 * 就像下面這樣：
 * NANOSECONDS.convert(delta,MILLISECONDS);
 * 
 * 在getDelay()中，希望使用的單位是作為unit引數傳遞進來的，你使用它將當前時間與觸發時間之間的差轉換為呼叫者
 * 要求的單位，而無需只掉這些單位是什麼（這是策略設計模式的一個簡單示例，在這種模式中，演算法的一部分是作為引數
 * 傳遞進來的）。
 * 
 * 為了排序，Delayed介面還繼承了Comparable介面，因此必須實現compareTo()，使其可以產生合理的比較。toString()
 * 和summary()提供了輸出格式化，而巢狀的EndSentinel類提供了一種關閉所有事物的途徑，具體做法是將其放置為佇列的
 * 最後一個元素。
 * 
 * @create @author Henry @date 2017-1-3
 */
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<DelayedTask>();

	public DelayedTask(int delayInMilliseconds) {
		delta = delayInMilliseconds;
		trigger = System.nanoTime() + TimeUnit.NANOSECONDS.convert(delta, TimeUnit.MILLISECONDS);
		sequence.add(this);
	}

	@Override
	public void run() {
		System.out.println(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 String toString() {
		return String.format("[%1$-4d]", delta) + " Task " + id;
	}

	public String summary() {
		return "(" + id + ":" + delta + ")";
	}

	public static class EndSentinel extends DelayedTask {
		private ExecutorService exec;

		public EndSentinel(int delay, ExecutorService e) {
			super(delay);
			exec = e;
		}

		@Override
		public void run() {
			for (DelayedTask pt : sequence) {
				System.out.println(pt.summary() + " ++");
			}
			System.out.println();
			System.out.println(this + " Calling shutdownNow()");
			exec.shutdownNow();
		}
	}
}
/**
 * 注意，因為DelayedTaskConsumer自身是一個任務，所以它由自己的Thread，它可以使用這個執行緒來執行從佇列中獲取
 * 的所有任務。由於這個任務是按照佇列優先順序的順序執行的，因此在本例中不需要啟動任何單獨的執行緒來執行DelayedTask.
 * 
 * @create @author Henry @date 2017-1-3
 */
class DelayedTaskConsumer implements Runnable {
	private DelayQueue<DelayedTask> q;

	public DelayedTaskConsumer(DelayQueue<DelayedTask> q) {
		this.q = q;
	}

	@Override
	public void run() {
		try {
			while (!Thread.interrupted())
				q.take().run();
				//new Thread(q.take()).start();
		} catch (InterruptedException e) {
			System.err.println("InterruptedException");
		}
		System.out.println("Finished DelayedTaskConsumer");
	}
}

/**
 * 從輸出中可以看到，任務建立的順序對執行順序沒有任何影響，任務是按照所期望的延遲順序執行的。
 * 
 * @create @author Henry @date 2017-1-3
 */
public class DelayQueueDemo {
	public static void main(String[] args) {
		Random rand = new Random(47);
		ExecutorService exec = Executors.newCachedThreadPool();
		DelayQueue<DelayedTask> queue = new DelayQueue<DelayedTask>();
		// Fill with tasks that have random delays;
		for (int i = 0; i < 5; i++)
			queue.put(new DelayedTask(rand.nextInt(5000)));
		// Set the stopping point
		queue.add(new DelayedTask.EndSentinel(5000, exec));
		exec.execute(new DelayedTaskConsumer(queue));
	}
}
 

輸出結果：

[555 ] Task 1 ---
[961 ] Task 4 ---
[1693] Task 2 ---
[1861] Task 3 ---
[4258] Task 0 ---
(0:4258) ++
(1:555) ++
(2:1693) ++
(3:1861) ++
(4:961) ++
(5:5000) ++

[5000] Task 5 Calling shutdownNow()
Finished DelayedTaskConsumer