JUC---Executor框架

前言

我们知道创建线程的方式有4种
1、继承Thread类，重写run方法
2、实现Runable接口，覆写run方法（推荐）
原因：

• 实现Runable接口避免多继承局限
• 实现Runable接口更好的体现了共享的概念

3、实现Callable接口，可以有返回值，可以抛出异常
鉴于Callable平时用的可能比较少，举个简单的栗子

public class CallableTest implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int count = 0;
        for (int i = 1; i <= 10; i++) {
            count += i;
        }
        return count;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<Integer>(new CallableTest());
        new Thread(task).start();
        System.out.println(task.get());

    }
}

4、就是今天的主角线程池啦

为什么要用线程池

基于对象复用的思想，无论是线程池或者是连接池，都是为了高效利用资源。
在java种，线程的创建和销毁是一项昂贵的操作，因为有系统调用。”为每一个任务分配一个线程“，这种方法线程生命周期开销很高（线程创建，请求延迟等时间），资源消耗多（比如内存，给垃圾回收器带来很大负担），稳定性不好（因为可创建线程的数量是有限制的）。所以线程池应运而生。

Executor框架

Executor框架是连接池的实现，是一个异步任务执行框架。这是框架的结构图。

Executor：只是一个简单的接口，其只定义了一个execute()方法：void execute(Runnable command);，只能提交Runnable形式的任务，不支持提交Callable带有返回值的任务。
ExecutorService：ExecutorService在Executor的基础上加入了线程池的生命周期管理，我们可以通过shutdown()或shutdownNow()方法来关闭我们的线程池。ExecutorService支持提交Callable形式的任务，提交完Callable任务后我们拿到一个Future，它代表一个异步任务执行的结果。关于shutdown和shutdownNow方法我们需要注意的是：这两个方法是非阻塞的，调用后立即返回，不会等待线程池关闭完成。如果我们需要等待线程池处理完成再返回可以使用ExecutorService#awaitTermination来完成。
shutdown() 方法平缓的关闭，即不再接收新任务，等待线程池中已经运行的任何和阻塞队列中等待执行的任务执行完成。
**shutdownNow()**尝试取消正在执行的任务，阻塞队列种的任务不再被执行，并讲阻塞队列中等待的线程作为返回值返回。
ThreadPoolExecutor：线程池中最核心的类，说一下它的每一个参数。

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

1、corePoolSize：线程池的核心线程数目，当一个请求进来时如果当前线程池中线程数量小于这个值，则直接通过ThreadFactory新建一个线程来处理这个请求，如果已有线程数量大于等于这个值则将请求放入阻塞队列中。
2、maximumPoolSize：线程池的最大线程数目，当线程池数量已经等于corePoolSize并且阻塞队列也已经满了，则看线程数量是否小于maximumPoolSize：如果小于则创建一个线程来处理请求，否则使用“饱和策略”来拒绝这个请求。对于大于corePoolSize部分的线程，称作这部分线程为“idle threads”，这部分线程会有一个最大空闲时间，如果超过这个空闲时间还没有任务进来则将这些空闲线程回收。
3、keepAliveTime和unit：这两个参数主要用来控制idle threads的最大空闲时间，超过这个空闲时间空闲线程将被回收。这里有一点需要注意，ThreadPoolExecutor中有一个属性:private volatile boolean allowCoreThreadTimeOut;，这个用来指定是否允许核心线程空闲超时回收，默认为false，即不允许核心线程超时回收，核心线程将一直等待新任务。如果设置这个参数为true，核心线程空闲超时后也可以被回收。
4、workQueue：阻塞队列，超过corePoolSize部分的请求放入这个阻塞队列中等待执行。阻塞队列分为有界阻塞队列和无界阻塞队列。在创建阻塞队列时如果我们指定了这个队列的“capacity”则这个队列就是有界的，否则是无界的。这里有一点需要注意：使用线程池之前请明确是否真的需要无界阻塞队列，如果阻塞队列是无界的，会导致大量的请求堆积，进而造成内存溢出系统崩溃。
5、threadFactory：是一个线程池工厂，主要用来为线程池创建线程，我们可以定制一个ThreadFactory来达到统一命名我们线程池中的线程的目的。
6、handler：饱和策略，用来拒绝多余的请求。饱和策略有：CallerRunsPolicy：请求脱离线程池运行（调用者线程来运行这个任务）；AbortPolicy：（默认）抛出RejectedExecutionException异常；DiscardPolicy：丢弃这个任务，即什么也不做；DiscardOldestPolicy：将阻塞队列中等待时间最久的任务删除（即队列头部的任务），将新的任务加入队尾。如果阻塞队列是一个优先级队列，那么这样将会抛弃优先级最高的任务，所以不要将这个策略和优先级队列一起使用。

ScheduledThreadPoolExecutor：ThreadPoolExecutor子类，它在ThreadPoolExecutor基础上加入了任务定时执行的功能。

Executors

Executors是一个工厂类，主要用来创建ExecutorService，ScheduledExecutorService等线程池。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

这个静态方法用来创建固定线程数目的线程池，可以看到其设置的corePoolSize和maximumPoolSize都是nThreads，其设定的阻塞队列是无界的，也就说多余的请求将一直积压在队列中进行等待，有可能造成内存溢出。

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

注意到这个方法创建的核心线程数是0，maximumPoolSize是一个最大值，空闲线程的最大空闲时间是一分钟，阻塞队列是一个SynchronousQueue。SynchronousQueue可以用来避免排队，已经直接将任务从生产者移交给工作者线程。要将一个元素放入SynchronousQueue中，必需有一个线程正在等待接收这个元素。如果没有等待线程，若当前线程池大小小于最大值，则创建一个新线程，否则，拒绝这个任务。只有当线程池是无界或可以拒绝任务时使用它。

public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

这个方法用来创建一个“工作窃取(work stealing)”ForkJoinPool线程池，下面详细介绍ForkJoinPool。

注：上面的这些并不是Executors中全部的方法，只是一部分。

ForkJoinPool

Doug Lea在JDK7中引入了Fork/Join框架，ForkJoinPool不同于ThreadPoolExecutor，它是一种基于"分治"思想的计算框架。java8的stream API中很多地方都有用到ForkJoinPool。ForkJoinPool中的工作线程会对自己的任务按照一定的粒度进行拆分，一个大任务拆分成多个子任务之后，子任务放入工作队列中等待执行。当一个线程的工作队列为空是可以从其他线程的工作队列中steal任务执行。这也是"work-stealing"的由来。

基本思想

1、ForkJoinPool 的每个工作线程都维护着一个工作队列（WorkQueue），这是一个双端队列（Deque），里面存放的对象是任务（ForkJoinTask）。
2、每个工作线程在运行中产生新的任务（通常是因为调用了 fork()）时，会放入工作队列的队尾，并且工作线程在处理自己的工作队列时，使用的是"LIFO"方式，也就是说每次从队尾取出任务来执行。
3、每个工作线程在处理自己的工作队列同时，会尝试窃取一个任务（或是来自于刚刚提交到 pool 的任务，或是来自于其他工作线程的工作队列），窃取的任务位于其他线程的工作队列的队首，也就是说工作线程在窃取其他工作线程的任务时，使用的是 FIFO 方式。
4、在遇到 join() 时，如果需要 join 的任务尚未完成，则会先处理其他任务，并等待其完成。
5、在既没有自己的任务，也没有可以窃取的任务时，进入休眠。

fork
fork将任务放入任务隶属的工作线程的工作队列中。

public final ForkJoinTask<V> fork() {
    Thread t;
    if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
        ((ForkJoinWorkerThread)t).workQueue.push(this);
    else
        ForkJoinPool.common.externalPush(this);
    return this;
}

join
1、检查调用 join() 的线程是否是 ForkJoinThread 线程。如果不是（例如 main 线程），则阻塞当前线程，等待任务完成。如果是，则不阻塞。
2、查看任务的完成状态，如果已经完成，直接返回结果。
3、如果任务尚未完成，但处于自己的工作队列内，则完成它。
4、如果任务已经被其他的工作线程偷走，则窃取这个小偷的工作队列内的任务（以 FIFO 方式），执行，以期帮助它早日完成欲 join 的任务。
5、如果偷走任务的小偷也已经把自己的任务全部做完，正在等待需要 join 的任务时，则找到小偷的小偷，帮助它完成它的任务。
6、递归地执行第5步。

以上就是 fork() 和 join() 的原理，这可以解释 ForkJoinPool 在递归过程中的执行逻辑，但还有一个问题：
最初的任务是 push 到哪个线程的工作队列里的？这就涉及到 submit() 函数的实现方法了。

submit
其实除了前面介绍过的每个工作线程自己拥有的工作队列以外，ForkJoinPool 自身也拥有工作队列，这些工作队列的作用是用来接收由外部线程（非 ForkJoinThread 线程）提交过来的任务，而这些工作队列被称为 submitting queue 。

submit() 和 fork() 其实没有本质区别，只是提交对象变成了 submitting queue 而已（还有一些同步，初始化的操作）。submitting queue 和其他 work queue 一样，是工作线程”窃取“的对象，因此当其中的任务被一个工作线程成功窃取时，就意味着提交的任务真正开始进入执行阶段。

所以ForkJoinPool一般适合一些cpu密集型任务，而不是I/O密集型。

总结

1、使用Executors创建线程池时一定要注意有界无界，避免请求过多导致内存溢出。
2、线程池应该声明为全局变量。

参考文章：
线程池
ForkJoinPool
Runable，Callable，Future的区别
《Java并发编程实战》