谁能给个线程池应用的例子程序 谢谢了

Question

谁能给个线程池应用的例子程序   谢谢了谢谢

Answer 1

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;
      taskQueue.clear();
      interrupt();
    }
  }   /**
   * Closes this ThreadPool and waits for all running threads to finish. Any
   * waiting tasks are executed.
   */
  public void join() {
    // notify all waiting threads that this ThreadPool is no
    // longer alive
    synchronized (this) {
      isAlive = false;
      notifyAll();
    }     // wait for all threads to finish
    Thread[] threads = new Thread[activeCount()];
    int count = enumerate(threads);
    for (int i = 0; i < count; i++) {
      try {
        threads[i].join();
      } catch (InterruptedException ex) {
      }
    }
  }   /**
   * A PooledThread is a Thread in a ThreadPool group, designed to run tasks
   * (Runnables).
   */
  private class PooledThread extends Thread {     public PooledThread() {
      super(ThreadPool.this, "Zigzag_ThreadPool-" + (threadID++));
    }     public void run() {
      while (!isInterrupted()) {         // get a task to run
        Runnable task = null;
        try {
          task = getTask();
        } catch (InterruptedException ex) {
        }         // if getTask() returned null or was interrupted,
        // close this thread by returning.
        if (task == null) {
          return;
        }         // run the task, and eat any exceptions it throws
        try {
          task.run();
        } catch (Throwable t) {
          uncaughtException(this, t);
        }
      }
    }
  }
}

Answer 2

直接用这个，jdk自带的,SnmpThread 是你自己写的Thread,怎么写Thread就不用贴了吧private ExecutorService pool = Executors.newFixedThreadPool(ThreadSize);private static final int ThreadSize = 15;/**
 * start method
 */
public void init() {
for (int i = 0; i < ThreadSize; i++) {
SnmpThread sp = new SnmpThread("你要初始化的参数");
pool.execute(sp);
}
} public void stop() {
pool.shutdown();
}