DelayQueue模拟TImer和scheduler

package concurrency.test;

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

import java.util.ArrayList;
import java.util.List;
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;

import static util.Print.*;

class DelayTaskScheduler implements Runnable,Delayed
{
	private static int counter = 0;
	
	private static final int id = counter++;
	
	private final int delta;
	
	private final long trigger;
	
	protected static List<DelayTaskScheduler> sequence = new ArrayList<DelayTaskScheduler>();
	
	public DelayTaskScheduler(int delayInMillseconds)
	{
		delta = delayInMillseconds;
		trigger = System.nanoTime() + NANOSECONDS.convert(delta, MILLISECONDS);
		sequence.add(this);
	}
	
	public void run()
	{
		print("Play this game");
		print(this + " ");
	}

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

	public long getDelay(TimeUnit unit)
	{
		return unit.convert(trigger - System.nanoTime(), NANOSECONDS);
	}
	
	@Override
	public String toString()
	{
		return String.format("[%1$-4d]", delta) + " Task : " + id;
	}
	
	public String summary()
	{
		return "(" + id + " : " + delta + " )";
	}
	
	/**
	 *	用于关闭线程池
	 *  以及打印输出所有DelayedTask任务参数的一个小兵
	 */
	public static class Endsentinel extends DelayTaskScheduler
	{
		private ExecutorService exec = null;

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

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

class DelayTaskSchedulerConsumer implements Runnable
{
	private DelayQueue<DelayTaskScheduler> q;
	public DelayTaskSchedulerConsumer(DelayQueue<DelayTaskScheduler> q)
	{
		this.q = q;
	}
	public void run()
	{
		try
		{
			while(!Thread.interrupted())
			{
				q.take().run();
			}
		} catch (InterruptedException e)
		{
			print("DelayTaskSchedulerConsumer InterruptedException");
		}
		print("Finished DelayTaskSchedulerConsumer");
	}
}

public class GreenhouseSchedulerDelayQueueDemo
{
	public static void main(String args[])
	{
		ExecutorService exec = Executors.newCachedThreadPool();
		DelayQueue<DelayTaskScheduler> queue = new DelayQueue<DelayTaskScheduler>();
		
		for(int i = 0; i < 5; i++)
		{
			queue.put(new DelayTaskScheduler(1000 * i));
		}
		queue.add(new DelayTaskScheduler.Endsentinel(5000, exec));
		
		exec.execute(new DelayTaskSchedulerConsumer(queue));
	}
}