DelayQueue

package concurrency;

import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static util.Print.print;

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;

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 delayInMillseconds)
	{
		delta = delayInMillseconds;
		trigger = System.nanoTime() + NANOSECONDS.convert(delta, MILLISECONDS);
		sequence.add(this);
	}

	public int compareTo(Delayed o)
	{
		DelayedTask that = (DelayedTask) o;
		if (this.trigger < that.trigger)
			return -1;
		if (this.trigger > that.trigger)
			return 1;
		return 0;
	}

	public long getDelay(TimeUnit unit)
	{
		return unit.convert(trigger - System.nanoTime(), NANOSECONDS);
	}

	public void run()
	{
		print(this + " ");
	}

	@Override
	public String toString()
	{
		// return String.format("%1$-4d", delta + " Task : " + id);
		return String.format("[%1$-4d]", delta) + " Task " + id;
	}

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

	
	/**
	 *	用于关闭线程池
	 *  以及打印输出所有DelayedTask任务参数的一个小兵
	 */
	public static class Endsentinel extends DelayedTask
	{
		private ExecutorService exec = null;

		public Endsentinel(int delayInMillseconds, ExecutorService e)
		{
			super(delayInMillseconds);
			exec = e;
		}

		public void run()
		{
			for (DelayedTask pt : sequence)
			{
				print(pt.summary() + " ");
			}
			print();
			print(this + "Calling shutdownNow()");
			exec.shutdownNow();
		}
	}
}

class DelayedTaskConsumer implements Runnable
{
	private DelayQueue<DelayedTask> q;

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

	public void run()
	{
		try
		{
			while (!Thread.interrupted())
			{
				q.take().run();
			}
		} catch (InterruptedException e)
		{
			// Acceptable way to exit;
			print("DelayedTaskConsumer InterruptedException");
		}
		print("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>();
		// Fill with tasks that have random delays:

		//添加20个人物，任务的优先级随机
		for (int i = 0; i < 20; i++)
		{
			queue.put(new DelayedTask(rand.nextInt(5000)));
		}
		//添加一个最大的DelayedTask，最后执行，关闭线程池
		queue.add(new DelayedTask.Endsentinel(5000, exec));
		//执行DelayedTask，按照trigger排序进行人物，trigger越小，DelayedTask优先执行权越高
		exec.execute(new DelayedTaskConsumer(queue));
	}
}