《java.util.concurrent包源码阅读》09线程池系列之介绍篇

public interface Executor {
    void execute(Runnable command);
}

// 发出关闭信号，不会等到现有任务执行完成再返回，但是现有任务还是会继续执行，
// 可以调用awaitTermination等待所有任务执行。不再接受新的任务。
void shutdown();

// 立刻关闭，尝试取消正在执行的任务（不保证会取消成功），返回未被执行的任务
List shutdownNow();

// 是否发出关闭信号
boolean isShutdown();

// 是否所有任务都执行完毕在shutdown之后，也就是如果不调用shutdownNow或者
// shutdown是不可能返回true
boolean isTerminated();

// 进行等待直到所有任务完成或者超时
boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

 Future submit(Callable task);

 Future submit(Runnable task, T result);

Future submit(Runnable task);

 List> invokeAll(Collectionextends Callable> tasks)
        throws InterruptedException;

 List> invokeAll(Collectionextends Callable> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

 T invokeAny(Collectionextends Callable> tasks)
        throws InterruptedException, ExecutionException;

 T invokeAny(Collectionextends Callable> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

public interface Callable {
    V call() throws Exception;
}

public interface Future {

    //取消任务，参数mayInterruptIfRunning为true时，如果要取消的任务正在执行，
    //会把执行这个任务的线程设为中断，为false时，正在执行的任务会被允许执行完成
    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    //获取执行结果，如果任务执行中，会等到任务完成再返回
    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

public interface ScheduledExecutorService extends ExecutorService {

    public ScheduledFuture schedule(Runnable command,
                                       long delay, TimeUnit unit);

    public  ScheduledFuture schedule(Callable 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);

}