import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CyclicExecutionOfThreads
{

	public static void main(String args[])
	{

		int totalNumOfThreads = 10;
		PrintJob printJob = new PrintJob(totalNumOfThreads);

		/*
		 * MyRunnable runnable = new MyRunnable(printJob, 1); Thread t1 = new
		 * Thread(runnable);
		 *
		 * MyRunnable runnable2 = new MyRunnable(printJob, 2); Thread t2 = new
		 * Thread(runnable2);
		 *
		 * MyRunnable runnable3 = new MyRunnable(printJob, 3); Thread t3 = new
		 * Thread(runnable3);
		 *
		 * t1.start(); t2.start(); t3.start();
		 */

		// OR
		ExecutorService executorService = Executors.newFixedThreadPool(totalNumOfThreads);
		Set<Runnable> runnables = new HashSet<Runnable>();

		for (int i = 1; i <= totalNumOfThreads; i++)
		{
			MyRunnable command = new MyRunnable(printJob, i);
			runnables.add(command);
			executorService.execute(command);
		}

		executorService.shutdown();
	}
}

class MyRunnable implements Runnable
{

	PrintJob printJob;
	int threadNum;

	public MyRunnable(PrintJob job, int threadNum)
	{
		this.printJob = job;
		this.threadNum = threadNum;
	}

	@Override
	public void run()
	{
		while (true)
		{
			synchronized (printJob)
			{
				if (threadNum == printJob.counter)
				{
					printJob.printStuff();

					if (printJob.counter != printJob.totalNumOfThreads)
					{
						printJob.counter++;
					} else
					{

						System.out.println();
						// reset the counter
						printJob.resetCounter();
					}

					printJob.notifyAll();

				} else
				{
					try
					{
						printJob.wait();
					} catch (InterruptedException e)
					{
						e.printStackTrace();
					}
				}
			}

		}
	}
}

class PrintJob
{
	int counter = 1;
	int totalNumOfThreads;

	PrintJob(int totalNumOfThreads)
	{
		this.totalNumOfThreads = totalNumOfThreads;
	}

	public void printStuff()
	{
		System.out.println("Thread " + Thread.currentThread().getName() + " is printing");

		try
		{
			Thread.sleep(1000);
		} catch (InterruptedException e)
		{
			e.printStackTrace();
		}
	}

	public void resetCounter()
	{
		this.counter = 1;
	}
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class DelayQueueExample
{

	public static void main(String[] args)
	{

		BlockingQueue<DelayedElement> blockingQueue = new DelayQueue<DelayedElement>();

		try
		{
			blockingQueue.put(new DelayedElement(4000, "Message with delay 4s"));
			blockingQueue.put(new DelayedElement(2000, "Message with delay 2s"));
			blockingQueue.put(new DelayedElement(9000, "Message with delay 9s"));
		} catch (InterruptedException ie)
		{
		}

		while (!blockingQueue.isEmpty())
		{
			try
			{
				System.out.println(">>" + blockingQueue.take());
			} catch (InterruptedException ie)
			{
			}
		}
	}
}

class DelayedElement implements Delayed
{

	private long duration = 0;
	private String message;

	public DelayedElement(long duration, String name)
	{
		this.duration = System.currentTimeMillis() + duration;
		this.message = name;
	}

	@Override
	public int compareTo(Delayed o)
	{

		return (int) (this.duration - ((DelayedElement) o).getDuration());
	}

	/*
	 * Expiration occurs when an element's getDelay(TimeUnit unit) method
	 * returns a value less than or equal to zero.
	 */
	@Override
	public long getDelay(TimeUnit unit)
	{
		long diff = duration - System.currentTimeMillis();
		return unit.convert(diff, TimeUnit.MILLISECONDS);
	}

	public long getDuration()
	{
		return duration;
	}

	public void setDuration(long duration)
	{
		this.duration = duration;
	}

	public String getMessage()
	{
		return message;
	}

	public void setMessage(String message)
	{
		this.message = message;
	}

	@Override
	public String toString()
	{
		return "DelayedElement [duration=" + duration + ", message=" + message + "]";
	}
}

import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorInvokeAllExample
{

	public static void main(String[] args) throws InterruptedException, ExecutionException
	{
		ExecutorService executorService = Executors.newSingleThreadExecutor();

		Set<Callable<String>> callables = new HashSet<Callable<String>>();

		callables.add(new CallableTask("Hello 1"));
		callables.add(new CallableTask("Hello 2"));
		callables.add(new CallableTask("Hello 3"));

		List<Future<String>> futures = executorService.invokeAll(callables);

		for (Future<String> future : futures)
		{
			System.out.println("future.get = " + future.get());
		}
		executorService.shutdown();
	}
}

class CallableTask implements Callable<String>
{

	String message;

	public CallableTask(String message)
	{
		this.message = message;
	}

	@Override
	public String call() throws Exception
	{
		return message;
	}
}