Executor等系列概念介绍
这里对几个常见的的名词进行介绍
Executor
这是个接口，只声明了一个方法——
public interface Executor { void execute(Runnable command);－－－执行一个Runnable对象 }
Executors
然后是Executors类，这个可以看作是个公共类，它提供了许多强大有用的获取线程池的static方法：
1.public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。
2.public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池，调用execute将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线 程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
3.public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的Executor。
4.public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。
ExecutorService
这也是个接口，继承了Executor接口。我觉得这个可以理解成一个代表可控线程池的一个接口，是Java提供的一个线程池，也就是说，每次我们需要使用线程的时候，可以通过ExecutorService获得线程。它可以有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞，同时提供定时执行、定期执行、单线程、并发数控制等功能，也不用使用TimerTask了。
ExecutorService接口继承自Executor接口，它提供了更丰富的实现多线程的方法，比如，ExecutorService提供了关闭自己的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。 可以调用ExecutorService的shutdown（）方法来平滑地关闭 ExecutorService，调用该方法后，将导致ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类：一类是已经在执行的，另一类是还没有开始执行的)，当所有已经提交的任务执行完毕后将会关闭ExecutorService。因此我们一般用该接口来实现和管理多线程。
ExecutorService的生命周期包括三种状态：运行、关闭、终止。创建后便进入运行状态，当调用了shutdown（）方法时，便进入关闭状态，此时意味着ExecutorService不再接受新的任务，但它还在执行已经提交了的任务，当素有已经提交了的任务执行完后，便到达终止状态。如果不调用shutdown（）方法，ExecutorService会一直处在运行状态，不断接收新的任务，执行新的任务，服务器端一般不需要关闭它，保持一直运行即可。
线程池实现类——ThreadPoolExecutor
这个类可以说是Exector框架的核心所在，Executors工具类中提供的很多线程池都是产自这个ThreadPoolExecutor类的构造方法，只是不同的线程池用了不同的默认参数而已。
public ThreadPoolExecutor(int corePoolSize, －－－－池子里面的线程数量，即便idle状态的线程也会保留这个数量 int maximumPoolSize,－－－－池子里面能盛放最大线程数量 long keepAliveTime,－－－－当线程数量大于core核心数量的时候，并且里有idle状态的线程，那么最大可以被terminate的的等待时间 （就是在cpu借的线程资源如果闲置多久就必须还回去） TimeUnit unit,－－timeUnit BlockingQueue<Runnable> workQueue,－－－任务的队列 ThreadFactory threadFactory,－－－线程工厂 RejectedExecutionHandler handler) {－－－线程池处理不过来任务队列的时候的默认处理方法 if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0) throw new IllegalArgumentException(); if (workQueue == null || threadFactory == null || handler == null) throw new NullPointerException(); this.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; }
如果你了解这个ThreadPoolExecutor类，可以直接用它来自定义自己想要的线程池，如果不熟就直接用Executors来获取呗。
上个Executor系列框架的类图：
（图来自：https://www.cnblogs.com/congsg2016/p/5621746.html）
这个AbstractExecutorService就一个实现了ExecutorService接口的抽象类；
然后这个ScheduleExecutorService是和时间、周期操作有关的线程池接口，继承了ExecutorService接口；
这个ScheduledThreadPoolExecutor无疑是这个和时间周期相关的实现类，这个类继承了ThreadPoolExecutor类并实现了ScheduledExecutorService接口；
这个ForkJoinPool的优势在于，可以充分利用多cpu，多核cpu的优势，把一个任务拆分成多个“小任务”，把多个“小任务”放到多个处理器核心上并行执行；当多个“小任务”执行完成之后，再将这些执行结果合并起来即可。这种思想值得学习。
Callable和future
这两个都是接口。
Callable接口代表一段可以调用并返回结果的代码;Future接口表示异步任务，是还没有完成的任务给出的未来结果。所以说Callable用于产生结果，Future用于获取结果。
callable一般是配合ExecutorService来使用的，callable可以类比Runnable，但它是一个可以获得结果的Runnable。当你想获得一个线程的运行结果的时候，就可以用这个接口了。
Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。
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方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
isDone方法表示任务是否已经完成，若任务完成，则返回true；
get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。
FutureTask类
也就是说Future提供了三种功能：
1）判断任务是否完成；
2）能够中断任务；
3）能够获取任务执行结果。
因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。
FutureTask类实现了RunnableFuture接口——
public interface RunnableFuture<V> extends Runnable, Future<V> { void run(); }
其他另外自行查询
然后上一个例子来理解下Future-Callable机制：
这是个用两条线程一起寻找数组最大值的例子：
先是Callable实现类：
import java.util.concurrent.Callable; class FindMaxTask implements Callable<Integer> { private int[] data; private int start; private int end; FindMaxTask(int[] data, int start, int end) { this.data = data; this.start = start; this.end = end; } public Integer call() { int max = Integer.MIN_VALUE; for (int i = start; i < end; i++) { if (data[i] > max) max = data[i]; } return max; } }
这个call方法就有点像Runnable里面的run方法，但区别是当这个Callable所代表的线程run起来后，结束后会返回一个结果，而这个结果我们待会通过Future类可以获得。
import java.util.concurrent.*; public class MultithreadedMaxFinder { public static int max(int[] data) throws InterruptedException, ExecutionException { if (data.length == 1) { return data[0]; } else if (data.length == 0) { throw new IllegalArgumentException(); } // split the job into 2 pieces FindMaxTask task1 = new FindMaxTask(data, 0, data.length/2); FindMaxTask task2 = new FindMaxTask(data, data.length/2, data.length); // spawn 2 threads ExecutorService service = Executors.newFixedThreadPool(2); Future<Integer> future1 = service.submit(task1); Future<Integer> future2 = service.submit(task2); return Math.max(future1.get(), future2.get()); } }
这个代码下，两个子数组都是同时被搜索。
有一点要注意一下，当future1.get()方法被调用的时候，这个方法会被阻塞了，或者说理解成这个方法所在的线程（也就是主线程）会阻塞，直到这个future1代表的callable线程完成了它的call方法并返回结果后，才会调用future2.get()方法，所以很可能future2所表示的线程提前完成也就提前找到了第二个数组的max，这样future1.get()完后立刻调用future2.get()就可以获得值。
所以，利用ExecutorService、callable还有Future可以让我们可以创建很多不同的线程，然后按照需要的顺序得到我们想要的答案。
参考文章：
https://www.cnblogs.com/fengsehng/p/6048610.html——《为什么引入Executor线程池框架》讲线程池怎么用，很多例子
https://www.cnblogs.com/congsg2016/p/5621746.html——讲Executor框架中各个类、接口的大概关系
https://www.cnblogs.com/fengsehng/p/6048609.html——《Java程序员必须掌握的线程知识-Callable和Future》讲Callable、Future还有FutureTask
