Android/java 多线程(五)-ThreadPoolExecutor线程池的使用

多线程系列历史文章:
Android/java 多线程(一)-Thread的使用以及源码分析
Android/java 多线程(二)-Thread的好兄弟Handler
Android/java 多线程(三)-HandlerThread的使用场景及源码解析
Android/java多线程(四)-IntentService

前面几篇文章主要都是介绍的单个线程的运用以及原理，这篇文章开始讲解多个线程的运用

简介

线程池是一个能对多个线程进行统一管理的一套机制，它具有诸多的优点：

能对线程进行复用，当有空闲的线程，线程池会复用这些线程而不会去重新创建，节省了资源
能灵活创建各种线程使用场景，内部封装了常用线程池创建逻辑，并支持自定义线程池逻辑创建
能准确的对每一个线程进行管理，并能读取每个线程的一写基础信息，方便进行一些逻辑处理

缺点：
线程中的数据传递没有Handler机制方便

使用场景：
具有诸多耗时任务的情况，当系统为每一个任务创建一个线程，会占用系统的大量资源，容易引起界面的卡顿，线程池的复用机制就很好的解决了这个问题

常用的线程池的使用

自定义线程池

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue 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;
    }

传入不同的参数，实现的效果也不同,下面说一下每个参数的作用:

corePoolSize 核心线程数,，即使空闲时仍保留在池中的线程数,除非设置了allowCoreThreadTimeOut
maximumPoolSize 线程池中允许的最大线程数
keepAliveTime 顾名思义，线程终止前的存活时间，即当线程数大于核心线程数(corePoolSize )时,多余的空闲线程在终止之前等待新任务的最大时间
TimeUnit keepAliveTime的单位
workQueue 在执行任务之前用于保存任务的队列。该队列将仅保存execute方法提交的Runnable任务。
ThreadFactory 执行程序创建新线程时使用的工厂
RejectedExecutionHandler 执行被阻止时使用的处理程序

这里说一下各个参数的配置套路,当使用execute(Runnable)方法添加一个任务到队列中，如果corePoolSize比maximumPoolSize小，队列满了后就会去创建新的线程,当corePoolSize与maximumPoolSize相等时，就会创建一个固定大小的核心线程池。如果将maximumPoolSize设置为无限大(例如nteger.MAX_VALUE)，则是创建一个能容纳任意数量任务的线程池。
ThreadFactory的作用是用来创建新的线程的，它是一个接口,实现它即可创建一个新的线程：

public interface ThreadFactory {

    /**
     * Constructs a new {@code Thread}.  Implementations may also initialize
     * priority, name, daemon status, {@code ThreadGroup}, etc.
     *
     * @param r a runnable to be executed by new thread instance
     * @return constructed thread, or {@code null} if the request to
     *         create a thread is rejected
     */
    Thread newThread(Runnable r);
}

通过它，你可以指定线程的名称，优先级，守护进程等，如果不设置，则会默认使用Executors.defaultThreadFactory()，它会创建一个与所有线程与所有相同的ThreadGroup并且具有相同的优先级和非守护进程状态NORM_PRIORITY。
workQueue是一个排队策略,一般有三种:

直接切换：对应SynchronousQueue实现类，将任务直接交给线程处理，不需要另外的控制，通常需要配置一个无限制的maximumPoolSizes，以避免拒绝掉新提交的任务
无界队列:对应LinkedBlockingDeque实现类，它没有预定的容量，当有新的任务，会在队列中等待，直到加入到corePoolSize的线程中，如果corePoolSize线程一直很忙，也不会去创建新的线程，此时，最大值最小值对它没有任何的影响，每个任务与其他的任务都是独立的，不会互相影响
有边界的队列：例如ArrayBlockingQueue实现类,它有助于在使用有限的maxPoolSize时防止资源的耗尽，但它更难调整与控制。

一般情况下我们都可以通过java提供的工厂模式来构造我们的线程池策略，主要提供了以下几种方式:

newCachedThreadPool

特点:

线程重用，如果没有重用的线程，将会创建一个新的线程添加到池中
适合执行短期异步任务程序，默认为60秒的线程等待时间，超过就会终止与移除
闲置的线程不会消耗资源

源码配置：

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

使用场景:
它创建了一个无限扩大的线程池，但没有核心线程池，因此资源占用少，适合处理一些短期的异步任务

newFixedThreadPool

特点:

创建一个固定数量的线程池，不能随时的新建线程，如果队列已满，提交了新任务，必须等待一个可用的线程
线程会一直存在，直到调用shutdown方法

源码配置:

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

使用场景:
它创建了一个核心线程数与最大线程数相同的线程池，适用于已知任务数量，对线程数量进行限制的场景

newWorkStealingPool

特点:

创建使用所有给定并行级别的线程池，并且可以使用多个队列来减少占用

    public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

使用场景:
它能创建一个拥有多个任务队列的线程池，可以减少链接数。并且它是默认创建当前可用cpu数量的线程来并行执行，因此适用于非常耗时的操作，并且可以并行执行

newSingleThreadExecutor

特点：

有且只有一个任务处于活动状态
先提交的先执行，有任务顺序
当任务出现异常，会另创建一个新的线程替换

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue()));
    }

使用场景:
它是一个单例线程，并且有执行顺序，所以适用于有执行顺序的任务，并且有且只有一个任务是执行中的

ScheduledThreadPoolExecutor

特点：

能设置延迟时间，能定期执行
空闲的线程会保留

    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

使用场景：
它具有定时特性，因此可以用来执行周期行的任务

五大线程池介绍完毕，此外还有其他的常用方法:

execute(Runnable command) 提交任务，在将来的某个时间点执行任务
afterExecute(Runnale r,Throwable t) 在指定的Runnale执行后调用此方法
beforeExecute(Thread t,Runnable r)在给定的线程中执行给定的Runnable之前调用方法
funalize 当执行器不再被引用并且没有线程时，调用shundown
shundown 启动有序关闭，先前提交的任务会执行，执行完毕后关闭
shundownNow 主动停止执行中的任务，并返回正在执行等待的任务列表