[Java] 详解Java中的线程池

public interface executor {
 
  /**
   * 向线程池提交一个任务,交由线程池去执行
   */
  void execute(runnable command);
 
}

public interface executorservice extends executor {
 
  /**
   * 关闭线程池(等待队列中的任务被执行完毕)
   */
  void shutdown();
 
  /**
   * 立刻关闭线程池(不执行队列中的任务，并尝试中断当前执行的任务)
   */
  list<runnable> shutdownnow();
 
  /**
   * 判断线程池是否处于shutdown状态.
   */
  boolean isshutdown();
 
  /**
   * 判断线程池是否处于terminated状态.
   */
  boolean isterminated();
 
  /**
   * 若在指定时间内线程池处于terminated状态则立即返回true,否则超过时间后仍未为terminated状态则返回false.
   */
  boolean awaittermination(long timeout, timeunit unit) throws interruptedexception;
 
  /**
   * 向线程池提交一个任务并返回包含指定类型的future(根据callable的泛型)
   */
  <t> future<t> submit(callable<t> task);
 
  /**
   * 向线程池提交一个任务并指定任务执行结果的类型,返回包含指定类型的future.
   */
  <t> future<t> submit(runnable task, t result);
 
  /**
   * 向线程池提交一个任务并返回未知类型的future.
   */
  future<?> submit(runnable task);
 
  /**
   * 向线程池提交多个任务并返回指定类型的future列表.
   */
  <t> list<future<t>> invokeall(collection<? extends callable<t>> tasks) throws interruptedexception;
 
  /**
   * 向线程池提交多个任务并返回指定类型的future列表,如果在指定时间内没有执行完毕则直接返回.
   */
  <t> list<future<t>> invokeall(collection<? extends callable<t>> tasks, long timeout, timeunit unit) throws interruptedexception;
   
  /**
   * 向线程池提交多个任务,当任意一个任务执行完毕后返回指定类型的future.
   */
  <t> t invokeany(collection<? extends callable<t>> tasks) throws interruptedexception, executionexception;
 
  /**
   * 向线程池提交多个任务,在指定时间内,当任意一个任务执行完毕后返回指定类型的future,若超时则抛出异常.
   */
  <t> t invokeany(collection<? extends callable<t>> tasks, long timeout, timeunit unit) throws interruptedexception, executionexception, timeoutexception;
}

public interface future<v> {
 
  /**
   * 中断任务的执行
   */
  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<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 {
 
  /**
   * 在指定的延迟时间到达后执行任务一次
   */
  public scheduledfuture<?> schedule(runnable command,long delay, timeunit unit);
 
  /**
   * 在指定的延迟时间到达后执行任务一次
   */
  public <v> scheduledfuture<v> schedule(callable<v> callable,long delay, timeunit unit);
 
  /**
   * 在指定的初始化延迟时间到达后执行任务一次,往后每隔period时间执行任务一次.
   */
  public scheduledfuture<?> scheduleatfixedrate(runnable command,long initialdelay,long period,timeunit unit);
 
  /**
   * 在指定的初始化延迟时间到达后执行任务一次,往后每次任务执行完毕后相隔delay时间执行任务一次.
   */
  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);
}