Executor框架详解

java的线程既是工作单元，也是执行机制。从jdk5开始，把工作单元与执行机制分离开来。工作单元包括Runnable和Callable，而执行机制由Executor框架提供。这样一来Executor是基于生产者消费者模式的，提交任务的操作相当于生成者，执行任务的线程相当于消费者。

一、Executor框架的两级调度模型

在HotSpot VM的模型中，JAVA线程被一对一映射为本地操作系统线程。JAVA线程启动时会创建一个本地操作系统线程，当JAVA线程终止时，对应的操作系统线程也被销毁回收，而操作系统会调度所有线程并将它们分配给可用的CPU。

在上层，JAVA程序会将应用分解为多个任务，然后使用应用级的调度器（Executor）将这些任务映射成固定数量的线程；在底层，操作系统内核将这些线程映射到硬件处理器上。

1、从类图上看，Executor接口是异步任务执行框架的基础，该框架能够支持多种不同类型的任务执行策略。Executor接口就提供了一个执行方法，任务是Runnbale类型，不支持Callable类型。

public interface Executor {

    void execute(Runnable command);

}

2、ExecutorService接口实现了Executor接口，主要提供了关闭线程池和submit方法：

public interface ExecutorService extends Executor {

    List<Runnable> shutdownNow();

    boolean isTerminated();

    <T> Future<T> submit(Callable<T> task);

}

另外该接口有两个重要的实现类：ThreadPoolExecutor与ScheduledThreadPoolExecutor。其中ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务；而 ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行任务，或者定期执行命令。

在上一篇文章中，我是使用ThreadPoolExecutor来通过给定不同的参数从而创建自己所需的线程池，但是在后面的工作中不建议这种方式，推荐使用Exectuors工厂方法来创建线程池

Executor框架使用示意图

1、主线程首先要创建实现Runnable或者Callable接口的任务对象工具类Executors，可以把一个Runnable对象封装为一个Callable对象(Executors.callable(Runnable task) 或者 Executors.callable(Runnable task,Object resule))。

2、然后可以把Runnable对象直接交给ExecutorService执行(ExecutorService.execute(Runnable command))；或者可以把Runnable对象或Callable对象提交给ExecutorService执行(ExecutorService.submit(Runnable task) 或 ExecutorService.submit(Callable task))。

3、如果执行ExecutorService.submit(…)，ExecutorService将返回一个实现Future接口的对象（FutureTask）。由于FutureTask实现了Runnable，程序员也可以创建FutureTask，然后直接交给ExecutorService执行。

4、最后，主线程可以执行FutureTask.get()方法来等待任务执行完成。主线程也可以执行FutureTask.cancel(boolean mayInterruptIfRunning)来取消此任务的执行。

Executor框架的实现ThreadPoolExecutor

Executors可以创建3种类型的ThreadPoolExecutor：SingleThreadExecutor、FixedThreadExecutor 和CachedThreadPool

1、SingleThreadExecutor：单线程线程池

ExecutorService threadPool = Executors.newSingleThreadExecutor();

    public static ExecutorService newSingleThreadExecutor() {

        return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,

                                                                              0L, TimeUnit.MILLISECONDS,

                                                                              new LinkedBlockingQueue<Runnable>()));

    }

我们从源码来看可以知道，单线程线程池的创建也是通过ThreadPoolExecutor，里面的核心线程数和线程数都是1，并且工作队列使用的是无界队列。由于是单线程工作，每次只能处理一个任务，所以后面所有的任务都被阻塞在工作队列中，只能一个个任务执行。

2、FixedThreadExecutor：固定大小线程池

ExecutorService threadPool = Executors.newFixedThreadPool(5);

public static ExecutorService newFixedThreadPool(int nThreads) {

    return new ThreadPoolExecutor(nThreads, nThreads,

                                  0L, TimeUnit.MILLISECONDS,

                                  new LinkedBlockingQueue<Runnable>());

}

这个与单线程类似，只是创建了固定大小的线程数量。

3、CachedThreadPool:无界线程池

ExecutorService threadPool = Executors.newCachedThreadPool();

public static ExecutorService newCachedThreadPool() {

    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                  60L, TimeUnit.SECONDS,

                                  new SynchronousQueue<Runnable>());

}

无界线程池意味着没有工作队列，任务进来就执行，线程数量不够就创建，与前面两个的区别是：空闲的线程会被回收掉，空闲的时间是60s。这个适用于执行很多短期异步的小程序或者负载较轻的服务器。