详解Java中的线程池

public interface Executor {

  /**
   * 向线程池提交一个任务,交由线程池去执行
   */
  void execute(Runnable command);

}

public interface ExecutorService extends Executor {

  /**
   * 关闭线程池(等待队列中的任务被执行完毕)
   */
  void shutdown();

  /**
   * 立刻关闭线程池(不执行队列中的任务，并尝试中断当前执行的任务)
   */
  List shutdownNow();

  /**
   * 判断线程池是否处于shutdown状态.
   */
  boolean isShutdown();

  /**
   * 判断线程池是否处于terminated状态.
   */
  boolean isTerminated();

  /**
   * 若在指定时间内线程池处于terminated状态则立即返回true,否则超过时间后仍未为terminated状态则返回false.
   */
  boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;

  /**
   * 向线程池提交一个任务并返回包含指定类型的Future(根据Callable的泛型)
   */
   Future submit(Callable task);

  /**
   * 向线程池提交一个任务并指定任务执行结果的类型,返回包含指定类型的Future.
   */
   Future submit(Runnable task, T result);

  /**
   * 向线程池提交一个任务并返回未知类型的Future.
   */
  Future<&＃63;> submit(Runnable task);

  /**
   * 向线程池提交多个任务并返回指定类型的Future列表.
   */
   List> invokeAll(Collection<&＃63; extends Callable> tasks) throws InterruptedException;

  /**
   * 向线程池提交多个任务并返回指定类型的Future列表,如果在指定时间内没有执行完毕则直接返回.
   */
   List> invokeAll(Collection<&＃63; extends Callable> tasks, long timeout, TimeUnit unit) throws InterruptedException;
   
  /**
   * 向线程池提交多个任务,当任意一个任务执行完毕后返回指定类型的Future.
   */
   T invokeAny(Collection<&＃63; extends Callable> tasks) throws InterruptedException, ExecutionException;

  /**
   * 向线程池提交多个任务,在指定时间内,当任意一个任务执行完毕后返回指定类型的Future,若超时则抛出异常.
   */
   T invokeAny(Collection<&＃63; extends Callable> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

public interface Future {

  /**
   * 中断任务的执行
   */
  boolean cancel(boolean mayInterruptIfRunning);

  /**
   * 判断任务是否中断成功
   */
  boolean isCancelled();

  /**
   * 判断任务是否执行完成
   */
  boolean isDone();
  
  /**
   * 获取任务的执行结果直到任务执行完毕(阻塞线程)
   */
  V get() throws InterruptedException, ExecutionException;
 
  /**
   * 获取任务的执行结果,若在指定时间内任务仍然没有执行完毕则抛出TimeoutException
   */
  V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

public ThreadPoolExecutor(int corePoolSize,
             int maximumPoolSize,
             long keepAliveTime,
             TimeUnit unit,
             BlockingQueue workQueue,
             ThreadFactory threadFactory,
             RejectedExecutionHandler handler)

private static final int RUNNING  = -1；
private static final int SHUTDOWN  = 0； 
private static final int STOP    = 1；
private static final int TIDYING  = 2； 
private static final int TERMINATED = 3；

public static ExecutorService newCachedThreadPool() {
  return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue());
}

public static ExecutorService newFixedThreadPool(int nThreads) {
  return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue());
}

public static ExecutorService newSingleThreadExecutor() {
  return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,new LinkedBlockingQueue()));
}

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
    return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1));
}

public interface ScheduledExecutorService extends ExecutorService {

  /**
   * 在指定的延迟时间到达后执行任务一次
   */
  public ScheduledFuture<&＃63;> schedule(Runnable command,long delay, TimeUnit unit);

  /**
   * 在指定的延迟时间到达后执行任务一次
   */
  public  ScheduledFuture schedule(Callable callable,long delay, TimeUnit unit);

  /**
   * 在指定的初始化延迟时间到达后执行任务一次,往后每隔period时间执行任务一次.
   */
  public ScheduledFuture<&＃63;> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit);

  /**
   * 在指定的初始化延迟时间到达后执行任务一次,往后每次任务执行完毕后相隔delay时间执行任务一次.
   */
  public ScheduledFuture<&＃63;> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit);

}

public static ExecutorService newWorkStealingPool(int parallelism) {
    return new ForkJoinPool(parallelism,ForkJoinPool.defaultForkJoinWorkerThreadFactory,null, true);
}