异步任务执行器Executor简介
以前线程Thread既表示执行的任务，又表示执行的机制。在JDK1.5中，java并发框架提供了一种“执行服务”的相关API,它将"任务的执行"和"任务的提交“相分离，”执行服务“封装了任务执行的细节，对于任务提交者来说，它可进一步聚焦于任务本身，如任务提交、获取任务执行后的结果、取消任务而不需要关注任务执行的细节，如线程的创建、任务的调试、线程的复用或关闭等。
1.基本接口
任务执行服务主要涉及4个接口
-
Runnable和Callable： 表示要执行的异步任务
-
Executor和ExecutorService：表示执行任务的服务
-
Future : 表示任务执行后的结果
Runnable是我们最常用的异步任务接口，这个接口的方法没有返回值，不能抛出异常。而Callable接口就是为了解决Runnable的不足而在JDK1.5引入的接口，此接口的方法有返回值，且可抛出异常。
@FunctionalInterface public interface Callable<V> { V call() throws Exception; }
1)Executor接口
Executor接口也只有一个方法，这个方法接受一个Runnable类型的参数，这是个抽象方法，它无法指定任务该如何执行。它可能是新建一个线程执行任务，也可能是利用线程池中的一个线程，还可能是在调用者线程中执行。
public interface Executor { void execute(Runnable command); }
ExecutorService扩展了Executor接口，它添加了一些新功能，如支持有返回结果的任务、支持超时任务、支持取消任务、支持批量提交任务。这里的submit方法，返回类型是Future，返回后，只表示任务已提交，不代表已经执行，具体执行与否要看”执行服务“如何调度，通过Future可以查询异步任务的状态、获取最终的结果、取消任务等。
public interface ExecutorService extends Executor { void shutdown(); List<Runnable> shutdownNow(); boolean isShutdown(); boolean isTerminated(); boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException; <T> Future<T> submit(Callable<T> task); <T> Future<T> submit(Runnable task, T result); Future<?> submit(Runnable task); <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException; <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit) throws InterruptedException; <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException; <T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }
2)Future接口
Future接口是对任务的结果做了进一步封装，字面上”future"是未来的意思，这里确实是表示“未来（或最终）的结果”，“结果”需要等待。
public interface Future<V> { boolean cancel(boolean mayInterruptIfRunning); boolean isCancelled(); boolean isDone(); V get() throws InterruptedException, ExecutionException; V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }
cancel()方法用于取消异步任务，若任务已完成、已取消或因其他原因不能取消等原因而导致任务取消失败就会返回false,反之返回true. 如果任务还未开始，则不再运行，但若任务已经在运行，则不一定能取消这个任务。参数mayInterruptIfRunning表示，如果任务正在执行，是否调用Thread.interrupt()方法中断线程，而interrupt()方法只是设置线程中断标志，它不一定能真的中断线程。
isCancelled() 和isDone()分别返回任务是否被取消、任务是否已完成的布尔值。只要cancel方法返回true,那么即使执行任务的线程还未结束，isCancelled方法也一定会返回true。不管什么原因，无论是任务正常结束、任务抛出异常或任务被取消，只要任务结束了，isDone都会返回true.
get()方法用于返回异步任务的结果，若任务未完成，当前线程则会阻塞待。get(long,TimeUnit)方法需要设定等待时长，若在给定的时间内还未完成任务，则会抛出TimeoutException异常。
get方法的最终结果大致有3种： ①任务正常完成，get方法返回任务的执行结果，若任务是Runnable且入参未提供结果，最终返回null ②任务被取消了，get方法会抛出CancellationException. ③任务执行过程中抛出了异常，get方法会将异常包装为ExecutionException重新抛出，此异常的getCause方法可获得原始异常。
Future是实现”任务的提交“与”任务的执行“相分离的关键，它是两者的桥梁，它使任务的提交者和任务的执行器的关注点相隔离，同时又让两者彼此联系。
2.用法示例
下面的例子中，使用异步任务，计算0-300的累加结果，在计算出结果前Future的get()方法将阻塞等待。
这里使用了Executors工具类的newSingleThreadeExecutor方法创建一了个执行服务。Executors有很多静态方法，分别创建各种线程池执行服务。
class SimpleTaskTest { static class Accumlation implements Callable<Integer> { @Override public Integer call() throws Exception { int sum =0; for (int i = 0; i < 300; i++) { sum += i; Thread.sleep(10); } return sum; } } public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService executor = Executors.newSingleThreadExecutor(); Future<Integer> future = executor.submit(new Accumlation()); long start = System.currentTimeMillis(); int result = future.get(); System.out.println("Future.get方法等待了" + (System.currentTimeMillis() - start) + "毫秒才返回，计算结果：" + result); } }
打印的结果
Future.get方法等待了3147毫秒才返回，计算结果：44850
3.基本原理
1)ExecutorService实现
ExecutorService是Executor的子接口，它添加了一些新功能，如支持有返回结果的任务、支持超时任务、支持取消任务、支持批量提交任务。
public interface ExecutorService extends Executor { void shutdown(); List<Runnable> shutdownNow(); boolean isShutdown(); boolean isTerminated(); boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException; <T> Future<T> submit(Callable<T> task); <T> Future<T> submit(Runnable task, T result); Future<?> submit(Runnable task); <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException; <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit) throws InterruptedException; <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException; <T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }
①ExecutorService有两个关闭执行服务的方法，分别是shutdown()和shutdownNow. 两者关闭执行服务的方式有所差别，shutdown()方法调用后不会接受新的任务，但已提交的任务将继续执行(即使任务还未真正开始执行)；而shutdownNow()方法不仅不会接受新任务，而且还会终止已经提交但未执行的任务，对于正在执行的任务，一般调用Thread.interrupt()方法设置中断标志，不过线程可能不响应中断，shutdownNow会返回已提交但未执行的任务列表。shutdown和shutdownNow不会阻塞等待，它们返回后不代表所有任务都结束。
②isShutdown返回执行服务是否被关闭的布尔值(不会等待)，只要shutdown或shutdownNow任意一方法被调用后，isShutdwon都将返回true.
③awaitTermination方法用于等待执行服务中的所有任务完成，此方法需要设置超时时间，如果在限时间内所有任务都结束了（允许非正常结束），
④isTerminated 返回在执行服务关闭后所有任务是否已完成的布尔值，如果在此之前shutdownNow或shutdown没有被调用，这里永不可能返回true.
⑤三个submit方法都用于提交单任务，submit(Callable<T> )方法中入参Callable本身有返回结果 ；submit（Runnable,T)方法在设定任务的同时可以提供一个结果，在任务结束时将返回这个结果；submit(Runnable )方法入参没有提供结果，最终返回的结果是null 。
⑥ExecutorService有两类批量提交任务的方法，invokeAll和invokeAny,它们都有两个版本，一个不限时版本、一个超时版本。
invokeAll等待(给定的)所有任务完成，返回的Future集合中，每个Future的isDone方法都返回true,但isDone是true并不代表任务完成了，也有可能是因任务被取消而导致任务非正常结束。invokeAll的超时版本方法，需要指定等待时间的时间，若超时后还有任务还未完成，这些任务就会被取消。而invokeAny，只要有一个任务正常完成(没抛出异常)后，它就返回此任务的结果；在正常返回或异常抛出返回后，其他任务则会被取消。对于invokeAny的超时版本，如果在限时内有一任务正常(没抛出异常)完成，就返回此任务的结果 ,其他将任务会被取消;如果没有任务能在限时内成功完成返回，就抛出TimeoutException; 没有任务正常成功返回（可能是因发生某种异常而返回），将抛出ExecutionException.
在了解ExecutorService接口的相关抽象方法定义后，我们来进一步分析它的实现类和实现原理。
ExecutorService的主要实现类是ThreadPoolExecutor,它是基于线程池实现的，ExecutorService有一个很重要的抽象类AbstractExecutorService, 而且ThreadPoolExecutor就是直接继承于AbstractExecutorService。
我们可以基于此抽象类实现一个简易的ExecutorService。AbstractExecutorService提供了submit 、invokeAll和invokeAny的默认实现，子类只需要实现其他方法就行了。shutdown与isShutdown 等方法与生命周期管理有关，我暂时可以不用去管它，其实它的子类最关键在于实现execute方法，因为submit、invokeAll、invokeAny等方法底层主要还是调用execute方法。
import java.util.List; import java.util.concurrent.*; public class CustomizeExecutorService extends AbstractExecutorService { @Override public void shutdown() { System.out.println("=====shutdown====="); } @Override public List<Runnable> shutdownNow() { System.out.println("=====shutdownNow====="); return null; } @Override public boolean isShutdown() { return false; } @Override public boolean isTerminated() { return false; } @Override public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { return false; } @Override public void execute(Runnable command) { new Thread(command).start(); } } class Accumlation implements Callable<Integer> { @Override public Integer call() throws Exception { int sum = 0; for (int i = 0; i < 300; i++) { sum += i; Thread.sleep(10); } return sum; } public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService executor = new CustomizeExecutorService(); Future<Integer> future = executor.submit(new Accumlation()); long start = System.currentTimeMillis(); int result = future.get(); System.out.println("Future.get方法等待了" + (System.currentTimeMillis() - start) + "毫秒，计算结果：" + result); } }
打印结果
Future.get方法等待了3142毫秒，计算结果：44850
AbstractExecutorService的基本方法是submit，其他方法的实现可以此为参照。可以看下其submit系列方法的实现是怎样的。
public Future<?> submit(Runnable task) { if (task == null) throw new NullPointerException(); RunnableFuture<Void> ftask = newTaskFor(task, null); execute(ftask); return ftask; } public <T> Future<T> submit(Runnable task, T result) { if (task == null) throw new NullPointerException(); RunnableFuture<T> ftask = newTaskFor(task, result); execute(ftask); return ftask; } public <T> Future<T> submit(Callable<T> task) { if (task == null) throw new NullPointerException(); RunnableFuture<T> ftask = newTaskFor(task); execute(ftask); return ftask; }
不论入参是Runnable还是Callable,最终都会将其封装成RunnableFuture，而RunnableFuture又是Runnable的子接口，而后去调用execute(Runnable)，最后返回RunnableFuture 。这里有点奇怪的地方在于对入参的封装，其实质相当于将Runnable或Callable任务封装成Runnable结果。这里也再次体现出了RunnableFuture的作用，它是连接“任务的提交”和“任务的执行”的桥梁。
上面的submit方法体中调用newTaskFor，它实际上返回一个FutureTask类型的实例对象。
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) { return new FutureTask<T>(runnable, value); } protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { return new FutureTask<T>(callable); }
2)Future实现
上面的提到的RunnableFuture同时继承了Runnable和Future接口，RunnableFuture本身没有增加任何抽象方法.
public interface RunnableFuture<V> extends Runnable, Future<V> { void run();//此方法是父接口Runnable的抽象方法 }
而FutureTask又是RunnableFutrue接口的主要实现类,我们可以来看看其的实现细节
它有一个成员变量state表示状态
private volatile int state;
它有这些可能取值
private static final int NEW = 0;//刚开始的状态或任务在运行中 private static final int COMPLETING = 1;//临时状态，任务即将结束，正在设置结果 private static final int NORMAL = 2;//任务正常完成 private static final int EXCEPTIONAL = 3;//因抛出异常而结束任务 private static final int CANCELLED = 4;//任务被取消 private static final int INTERRUPTING = 5;//任务正在被中断 private static final int INTERRUPTED = 6;//任务被中断(中断的最终状态)
其他成员变量
private Callable<V> callable; private Object outcome; // non-volatile, protected by state reads/writes private volatile Thread runner; private volatile WaitNode waiters;
成员变量callable表示要执行的任务。
成员变量outcome表示任务的结果或任务非正常结束的异常
成员变量runner表示执行此任务的线程
成员变量waiter表示等待任务执行结果的等待栈表(数据结构是单向链表，先进后出)。WaitNode是一个简单的静态内部，一个成员变量thread表示等待结果的线程，另一个成员变量next表示下一个等待节点（线程）。
static final class WaitNode { volatile Thread thread; volatile WaitNode next; WaitNode() { thread = Thread.currentThread(); } }
FutureTask的构造方法会初始化callable和state。FutureTask的构造方法可以接受Runnable类型参数，它会调用Executors.callable将Runnable转换为Callable类型实例，以便于统一处理。
public FutureTask(Runnable runnable, V result) { this.callable = Executors.callable(runnable, result); this.state = NEW; // ensure visibility of callable }
任务执行服务会使用一个线程执行FutureTask的run方法，run方法的实现
public void run() { if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread())) //将当前线程设置为执行任务的线程 return; try { Callable<V> c = callable; if (c != null && state == NEW) { V result; boolean ran; try { result = c.call();//执行任务 ran = true; } catch (Throwable ex) { //运行时有异常，设置异常 result = null; ran = false; setException(ex); } if (ran) set(result);//设置结果 } } finally { // runner must be non-null until state is settled to // prevent concurrent calls to run() runner = null; //state已是最终状态，不再变化，将runer设为null,防止run方法被并发调用 // state must be re-read after nulling runner to prevent // leaked interrupts int s = state; //清空运行线程runner后再重新获取state,防止遗漏掉对中断的处理 if (s >= INTERRUPTING) handlePossibleCancellationInterrupt(s); } }
其主要逻辑是：
①检查状态，设置运行任务的线程
②调用callable的call方法去执行任务，并捕获运行中可能出现的异常
③如果任务正常完成，调用set设置任务的结果，将state设为NORMAL, 将结果保存到outcome ,唤醒所有等待结果的线程
⑤最后将运行线程runner清空，若状态可能是任务被取消的中断还要处理此中断。
对于任务提交者，可通过get方法获取任务的最终结果，它的超时版本是
public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { if (unit == null) throw new NullPointerException(); int s = state; if (s <= COMPLETING && //还未完成 (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING) //等待完成 //到了限定时间，任务仍未完成，抛出超时异常TimeoutException throw new TimeoutException(); return report(s);//报告结果 }
其主要逻辑是：若任务未完成就等待任务完成，最后调用report报告结果，report会根据状态返回结果或抛出异常。
而report方法的基本逻辑也很简单：若是任务正常结束就返回这个任务的结果，若是任务被取消，就抛出任务取消异常CancellationException，若是在执行任务过程中发生了异常就统一将其封装成ExecutionException并抛出。
private V report(int s) throws ExecutionException { Object x = outcome; if (s == NORMAL) return (V)x; if (s >= CANCELLED) throw new CancellationException(); throw new ExecutionException((Throwable)x); }
说到任务被取消，我们可以看看cancel(boolean)方法如何实现的
public boolean cancel(boolean mayInterruptIfRunning) { if (!(state == NEW && UNSAFE.compareAndSwapInt(this, stateOffset, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED))) //①不是NEW状态，表示任务至少是COMPLETING(即将结束)状态，返回false //②CAS更新state为INTERRUPTING或CANCELLED失败，返回false //只有state状态更新成功，才能取消任务（防止被并发调用） return false; try { // in case call to interrupt throws exception if (mayInterruptIfRunning) {//允许中断就设置中断标志 try { Thread t = runner; if (t != null) t.interrupt();//设置中断标志 } finally { // final state 设置中断的最终状态 //INTERRUPTING -> INTERRUPTED ,将state由“正在中断”更新为”已经中断“ UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); } } } finally { //从等待栈中唤醒并移除所有的线程(节点) finishCompletion(); } return true; }
其基本逻辑：
①任务已结束或被取消，返回false
②若mayInterruptIfRunning为true,调用interrupt设置中断标志，将state设置为INTERRUPTED,若mayInterruptIfRunning为false，将state设为CANCELLED.
③调用finishCompletion唤醒并移除等待栈中的所有线程
