以前线程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 )方法中入参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 ,唤醒所有等待结果的线程
④若执行任务过程中发生了异常，调用setException设置异常,将state设为EXCEPTIONAL ，将此异常也保存到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唤醒并移除等待栈的所有线程