package zigzag.threaddump.demo;

import java.util.*;

public class ThreadPoolTest {

      public static void main(String[] args) {
        if (args.length != 2) {
          System.out.println("Tests the ThreadPool task.");
          System.out
              .println("Usage: java ThreadPoolTest numTasks numThreads");
          System.out.println("  numTasks - integer: number of task to run.");
          System.out.println("  numThreads - integer: number of threads "
              + "in the thread pool.");
          return;
        }
        int numTasks = Integer.parseInt(args[0]);
        int numThreads = Integer.parseInt(args[1]);

        // create the thread pool
        ThreadPool threadPool = new ThreadPool(numThreads);

        // run example tasks
        for (int i = 0; i < numTasks; i++) {
          threadPool.runTask(createTask(i));
        }

        // close the pool and wait for all tasks to finish.
        threadPool.join();
      }

      /**
       * Creates a simple Runnable that prints an ID, waits 500 milliseconds, then
       * prints the ID again.
       */
      private static Runnable createTask(final int taskID) {
        return new Runnable() {
          public void run() {
            System.out.println("Task " + taskID + ": start");

            // simulate a long-running task
            try {
                int i = 0;
                while (i<99999L*2000)
                    i++;
              
            } catch (Exception ex) {
            }

            System.out.println("Task " + taskID + ": end");
          }
        };
      }

    }
    /**
     * A thread pool is a group of a limited number of threads that are used to
     * execute tasks.
     */

    class ThreadPool extends ThreadGroup {

      private boolean isAlive;

      private LinkedList taskQueue;

      private int threadID;

      private static int threadPoolID;

      /**
       * Creates a new ThreadPool.
       * 
       * @param numThreads
       *            The number of threads in the pool.
       */
      public ThreadPool(int numThreads) {
        super("Zigzag_ThreadPool-" + (threadPoolID++));
        setDaemon(true);

        isAlive = true;

        taskQueue = new LinkedList();
        for (int i = 0; i < numThreads; i++) {
          new PooledThread().start();
        }
      }

      /**
       * Requests a new task to run. This method returns immediately, and the task
       * executes on the next available idle thread in this ThreadPool.
       * <p>
       * Tasks start execution in the order they are received.
       * 
       * @param task
       *            The task to run. If null, no action is taken.
       * @throws IllegalStateException
       *             if this ThreadPool is already closed.
       */
      public synchronized void runTask(Runnable task) {
        if (!isAlive) {
          throw new IllegalStateException();
        }
        if (task != null) {
          taskQueue.add(task);
          notify();
        }

      }

      protected synchronized Runnable getTask() throws InterruptedException {
        while (taskQueue.size() == 0) {
          if (!isAlive) {
            return null;
          }
          wait();
        }
        return (Runnable) taskQueue.removeFirst();
      }

      /**
       * Closes this ThreadPool and returns immediately. All threads are stopped,
       * and any waiting tasks are not executed. Once a ThreadPool is closed, no
       * more tasks can be run on this ThreadPool.
       */
      public synchronized void close() {
        if (isAlive) {
          isAlive = false;