java线程池面试题----Executor框架解读实战

Executor 简介

从代码上看，Executor 是一个简单的接口，但它却是整个异步任务执行框架的基础，这个框架能支持多种不同类型的任务执行策略。他提供了一种标准的方法将任务的提交过程和执行过程解耦开来，任务用 Runnable 来表示。Executor 基于生产者-消费者模式，提交任务的线程相当于生产者，执行任务的线程相当于消费者。同时，Executor 的实现还提供了对任务执行的生命周期管理的支持。

Executor 引入的原因

大多数并发应用程序都是围绕[任务执行]来构造，应用程序的工作可以被分解到多个任务中，关键是如何安排好这些任务的执行。换句话说，就是有哪些执行策略可以供我们选择，来保证程序的正常运行。执行策略有下面三种方法，我们来看看。

串行执行

最简单最直接最粗暴的方法就是单线程的串行执行，每次只能执行一个任务，其他任务必须等待当前任务执行完成，才能进行。这在理论上可以的，但是它的缺陷也非常明显。假如当前任务是耗时操作或者是阻塞的，那么其他任务需要进行长时间的等待，这让客户端感觉到程序响应非常慢。特别是在服务器应用程序中，串行处理机制通常无法提供高吞吐率或快速响应性。它的缺陷总结如下：

1. 吞吐率低
2. 响应慢
3. 资源利用率低

无限制创建线程

这时，我们可能会想到的另一个方法，就是为每个任务都单独分配一个线程来执行，从而提高程序的响应性。因为这样可以做到任务并行处理，能同时处理多个请求，但是要保证任务处理代码是线程安全的。
然而，这种方法也存在着一定的缺陷，极端情况下，它会创建大量的线程，超过了一定的数量，它继续创建线程会降低程序的执行速度，甚至导致程序崩溃。所以，当需要创建大量线程时，它的缺点有：

1. 线程生命周期的开销非常高，会消耗大量的计算资源。
2. 资源消耗问题，大量空闲线程会占用很多内存。
3. 稳定性问题，超过了系统的限制数量，可能会导致OOM。

线程池的优势

上面提到的两种方式，都有着各自明显的缺点。串行执行的问题在于糟糕的响应性和吞吐率；为每个任务都创建线程的问题在于资源管理的复杂性。这两种方法看起来都是极端的情况，要么只创建一个，要么无线创建。
那么，我们是否可以通过限制线程的数量，找到一种介于两者之间平衡的方法来解决这些问题呢？答案是肯定的。各种执行策略都是一种资源管理工具，最佳的执行策略取决于可用的计算资源以及对服务质量的需求。我们可以通过限制并发任务的数量，来避免上面的两个问题。在此，我们引入线程池的概念。
线程池，构建一定数量的工作线程，它与工作队列密切相关。工作队列保存了所有待执行的任务，工作线程的主要工作就是从队列中获取任务，执行完成后返回线程池，等待下一个任务。它的优势也非常明显:

1. 可以重用现有线程，减少创建和销毁的频繁开销，提高响应性。
2. 线程数量可调节，灵活方便，防止过多线程耗尽内存。

总之，大多数情况下，应该运用线程池而不是其他方式来处理并发任务。

Executor 框架的组件

说了这么多，那到底 Executor 的框架是怎么样的呢？下面我们直接先来看它的框架类图。

框架类图

下面我们根据这个框架图，来简单说说各个类的情况。
(1) Executor 是一个简单的接口，如下所示：

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

(2) ExecutorService 在原有接口的基础上，添加生命周期的方法，它包括三种状态：运行，关闭，终止。

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;
}

(3) ThreadPoolExecutor 框架核心类，Executors 工具类最终是条用它来创建不同执行策略的Executor.所以我们也可以利用它来定制机子的执行策略。
(4) Executors 工具类，可以用它来创建各种各样的 Executor.比如下面这几种：

- newFixedThreadPool, 固定长度的线城池。
- newCacheThreadPool, 可缓存的线程池，可以回收空闲线程，任务多时则创建线程，数量没有限制。
- newSingleThreadExecutor, 单线程。
- newScheduledThreadPool, 固定长度线程池，可以延迟或定时执行。

(5) ExecutorCompletionService, 它融合了Executor 和 BlockingQueue。它将计算委托给 Executor,当任务执行结束时，结果会放入队列里面。其实就是通过阻塞队列作为中介来获取结果，而不是直接使用 Future 来获取。
任务执行的三个部分

框架使用示意图

它的框架使用示意图如下:

从图中可以看出整个执行的流程。但是图上得来终觉浅，绝知此事要躬行，还是用具体实例来演示吧。