1，Executor框架相关内容

Executor 框架主要包括三部分内容

1. 任务相关的：包含被执行的任务要实现的接口：Runnable接口或Callable接口

2. 任务的执行相关的：包含任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。Executor框架中有两个关键的类实现了ExecutorService接口（ThreadPoolExecutor和ScheduledThreadPoolExecutor）

3. 异步计算结果相关的：包含接口Future和实现Future接口的FutureTask类

Executors框架包括：

• Executor
• ExecutorService
• ThreadPoolExecutor
• Executors
• Future
• Callable
• FutureTask
• CompletableFuture
• CompletionService
• ExecutorCompletionService

2, Executor接口

Executor接口中定义了方法execute(Runable able)接口，该方法接受一个Runable实例，他来执行一个任务，任务即实现一个Runable接口的类。

3，ExecutorService 接口

ExecutorService继承于Executor接口，他提供了更为丰富的线程实现方法，比如ExecutorService提供关闭自己的方法，以及为跟踪一个或多个异步任务执行状况而生成Future的方法。

ExecutorService有三种状态：运行、关闭、终止。创建后便进入运行状态，当调用了shutdown()方法时，便进入了关闭状态，此时意味着ExecutorService不再接受新的任务，但是他还是会执行已经提交的任务，当所有已经提交了的任务执行完后，便达到终止状态。如果不调用shutdown方法，ExecutorService方法会一直运行下去，系统一般不会主动关闭。

4，ThreadPoolExecutor

线程池类，是我们常用到到。参考 线程池

5，Executors-工具类

Executors类，提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。常用的方法有：

//单线程线程池
public static ExecutorService newSingleThreadExecutor()
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)

//固定线程数的线程池
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)

//创建一个可缓存的线程池
public static ExecutorService newCachedThreadPool()
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)

//创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

这几种创建线程池的方法都是调用 ThreadPoolExecutor。

6，Future 结果

任务结果

7，Callable 接口

Callable 接口中定义了需要有返回的任务需要实现的方法。

Runnable 和 Callable 的区别：

1、最大的区别，runnable 没有返回值，而实现 callable 接口的任务线程能返回执行结果。

2、callable 接口实现类中的 call 方法允许异常向上抛出，可以在内部处理，try catch，但是 runnable 接口实现类中 run 方法的异常必须在内部处理，不能抛出。

callable 示例：

public void test() {
    Callable<String> callable = new Callable<String>() {
        @Override
        public String call() throws Exception {
            System.out.println(1/0);
            return "pz";
        }
    };
    FutureTask futureTask = new FutureTask(callable);
    Thread thread = new Thread(futureTask);
    thread.start();
    try {
        System.out.println(futureTask.get());
    }catch (Exception e){
        System.out.println(e.getMessage());
    }
}

runnable 示例：

public void runnableTest(){
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println(1);
        }
    }).start();
}

8，CompletionService 接口

CompletionService相当于一个执行任务的服务，通过submit丢任务给这个服务，服务内部去执行任务，可以通过服务提供的一些方法获取服务中已经完成的任务。

1，Future submit(Callable task)

用于向服务中提交有返回结果的任务，并返回Future对象

2，Future submit(Runnable task, V result);

用户向服务中提交有返回值的任务去执行，并返回Future对象

3，Future take() throws InterruptedException;

从服务中返回并移除一个已经完成的任务，如果获取不到，会一致阻塞到有返回值为止。此方法会响应线程中断。

4，Future poll();

从服务中返回并移除一个已经完成的任务，如果内部没有已经完成的任务，则返回空，此方法会立即响应。

5，Future poll(long timeout, TimeUnit unit) throws InterruptedException;

尝试在指定的时间内从服务中返回并移除一个已经完成的任务，等待的时间超时还是没有获取到已完成的任务，则返回空。此方法会响应线程中断

9，ExecutorCompletionService 接口

ExecutorCompletionService类是CompletionService接口的具体实现。

说一下其内部原理，ExecutorCompletionService创建的时候会传入一个线程池，调用submit方法传入需要执行的任务，任务由内部的线程池来处理；ExecutorCompletionService内部有个阻塞队列，任意一个任务完成之后，会将任务的执行结果（Future类型）放入阻塞队列中，然后其他线程可以调用它take、poll方法从这个阻塞队列中获取一个已经完成的任务，获取任务返回结果的顺序和任务执行完成的先后顺序一致，所以最先完成的任务会先返回。

10，CompletableFuture 接口

CompletableFuture是java8中新增的一个类，算是对Future的一种增强，用起来很方便，也是会经常用到的一个工具类。

1. 在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。

2. 它可能代表一个明确完成的Future，也有可能代表一个完成阶段（ CompletionStage ），它支持在计算完成以后触发一些函数或执行某些动作。

3. 它实现了Future和CompletionStage接口。CompletionStage 代表异步计算过程中的某一个阶段，一个阶段完成以后可能会触发另外一个阶段。

api 介绍：

public static CompletableFuture runAsync(Runnable runnable)
public static CompletableFuture runAsync(Runnable runnable, Executor executor)

创建一个异步操作， 不支持返回值，不传入 executor 使用 ForkJoinPool.commonPool()

public static CompletableFuture supplyAsync(Supplier supplier)
public static CompletableFuture supplyAsync(Supplier supplier, Executor executor)

创建一个异步操作，支持返回值，不传入 executor 使用 ForkJoinPool.commonPool()

public CompletableFuture whenComplete(BiConsumer<? super T,? super Throwable> action)
public CompletableFuture whenCompleteAsync(BiConsumer<? super T,? super Throwable> action)
public CompletableFuture whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor)

结算结果完成回调方法，whenCompaete，在当前线程执行。whenCompleteAsync 继续交给线程池执行。

public CompletableFuture exceptionally(Function<Throwable,? extends T> fn)

出现异常执行。

其他方法参考

单独列一篇出来