public interface Executor {

  /**
   * 向線程池提交一個任務(wù),交由線程池去執(zhí)行
   */
  void execute(Runnable command);

}

public interface ExecutorService extends Executor {

  /**
   * 關(guān)閉線程池(等待隊列中的任務(wù)被執(zhí)行完畢)
   */
  void shutdown();

  /**
   * 立刻關(guān)閉線程池(不執(zhí)行隊列中的任務(wù)，并嘗試中斷當(dāng)前執(zhí)行的任務(wù))
   */
  List<Runnable> shutdownNow();

  /**
   * 判斷線程池是否處于shutdown狀態(tài).
   */
  boolean isShutdown();

  /**
   * 判斷線程池是否處于terminated狀態(tài).
   */
  boolean isTerminated();

  /**
   * 若在指定時間內(nèi)線程池處于terminated狀態(tài)則立即返回true,否則超過時間后仍未為terminated狀態(tài)則返回false.
   */
  boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;

  /**
   * 向線程池提交一個任務(wù)并返回包含指定類型的Future(根據(jù)Callable的泛型)
   */
  <T> Future<T> submit(Callable<T> task);

  /**
   * 向線程池提交一個任務(wù)并指定任務(wù)執(zhí)行結(jié)果的類型,返回包含指定類型的Future.
   */
  <T> Future<T> submit(Runnable task, T result);

  /**
   * 向線程池提交一個任務(wù)并返回未知類型的Future.
   */
  Future<?> submit(Runnable task);

  /**
   * 向線程池提交多個任務(wù)并返回指定類型的Future列表.
   */
  <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;

  /**
   * 向線程池提交多個任務(wù)并返回指定類型的Future列表,如果在指定時間內(nèi)沒有執(zhí)行完畢則直接返回.
   */
  <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;
   
  /**
   * 向線程池提交多個任務(wù),當(dāng)任意一個任務(wù)執(zhí)行完畢后返回指定類型的Future.
   */
  <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;

  /**
   * 向線程池提交多個任務(wù),在指定時間內(nèi),當(dāng)任意一個任務(wù)執(zhí)行完畢后返回指定類型的Future,若超時則拋出異常.
   */
  <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

public interface Future<V> {

  /**
   * 中斷任務(wù)的執(zhí)行
   */
  boolean cancel(boolean mayInterruptIfRunning);

  /**
   * 判斷任務(wù)是否中斷成功
   */
  boolean isCancelled();

  /**
   * 判斷任務(wù)是否執(zhí)行完成
   */
  boolean isDone();
  
  /**
   * 獲取任務(wù)的執(zhí)行結(jié)果直到任務(wù)執(zhí)行完畢(阻塞線程)
   */
  V get() throws InterruptedException, ExecutionException;
 
  /**
   * 獲取任務(wù)的執(zhí)行結(jié)果,若在指定時間內(nèi)任務(wù)仍然沒有執(zhí)行完畢則拋出TimeoutException
   */
  V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

public ThreadPoolExecutor(int corePoolSize,
             int maximumPoolSize,
             long keepAliveTime,
             TimeUnit unit,
             BlockingQueue<Runnable> 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<Runnable>());
}

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

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

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 {

  /**
   * 在指定的延遲時間到達(dá)后執(zhí)行任務(wù)一次
   */
  public ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit);

  /**
   * 在指定的延遲時間到達(dá)后執(zhí)行任務(wù)一次
   */
  public <V> ScheduledFuture<V> schedule(Callable<V> callable,long delay, TimeUnit unit);

  /**
   * 在指定的初始化延遲時間到達(dá)后執(zhí)行任務(wù)一次,往后每隔period時間執(zhí)行任務(wù)一次.
   */
  public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit);

  /**
   * 在指定的初始化延遲時間到達(dá)后執(zhí)行任務(wù)一次,往后每次任務(wù)執(zhí)行完畢后相隔delay時間執(zhí)行任務(wù)一次.
   */
  public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit);

}

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