线程池，是时候做个了结了！

一直想不到一个好标题，刚刚灵光一现，想到这个标题，尽管有点任性，就姑且先这样吧。

前言：大概在我刚入职的时候，我的第一次面试，面试官问我实现多线程的方式有哪几种？我脱口而出extends Thread 然后…我卡壳了，我知道是跟Runnable有关的但是一紧张突然就忘了，其实紧张是个借口，主要是不常用。然后面试官并没有干到很诧异又问我那你知不知道线程池？沃日，这又是什么鬼？是一个放线程的大池子？我不知道也不敢说。只能说不知道。很尴尬的一次面试之后，我立马查了查线程池，当时感觉有点高深，因为线程都掌握的不怎么样，更何况线程池。不知不觉过去很长时间了，时至今日，是时候跟线程池做了了结了。

一、什么是线程池？
Android中线程池的概念来源于Java的Executor，他是一个接口。理所当然的应该去找他的实现了，那就是ThreadPoolExecutor。他通过很多参数来配置不同的线程池。也就是自定义线程池。一般Android开发中常用的线程池有4种，分别是
FixedThreadPool,CachedThreadPool,ScheduledThreadPool,SingleThreadExecutor，下面我会逐个介绍。

二、1+4种线程池
为什么说是1+4种呢？
1是ThreadPoolExecutor
4是
FixedThreadPool
CachedThreadPool
ScheduledThreadPool
SingleThreadExecutor

1、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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

corePoolSize：线程池的核心线程数。默认情况核心线程会在线程池中一直存活，即使他们一直处于闲置状态。如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置成true，那么闲置的核心线程会有超时时间，超过这个超时时间核心线程会被停止。这个时间由第三个参数keepAliveTime决定。

maximumPoolSize：线程池所能容纳的最大线程数。当活动线程数超过这个数量的时候，后面的任务会被阻塞。

keepAliveTime：保活时间。上面提到过，当ThreadPoolExecutor的allowCoreThreadTimeOut属性设置成true时，他会作用于核心线程，否则是作用于非核心线程。

unit：指定keepAliveTime的时间单位。如：毫秒，秒，分钟等。

workQueue：线程池中的任务队列。通过线程池的execute方法提交的Runnable对象会存储在这个参数中。

threadFactory：线程工厂。为线程池提供创建新线程的功能。

handler：这个我自己不知道怎么定义，看一下官方的解释：
A handler for tasks that cannot be executed by a {@link ThreadPoolExecutor}.
大概意思就是ThreadPoolExecutor执行不了的时候会用到这个参数。的确如此，我在之前的开发中碰到过一个异常：
java.util.concurrent.RejectedExecutionException。
这是由于我调用ThreadPoolExecutor的构造函数的时候传入的workQueue（即阻塞队列，BlockingQueue 的大小设置成128），代码如下：

private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(128);

当时我做一个查看相册里面所有图片的需求，我的手机图片大概有1000张左右，当我慢慢的滑动的时候，其实显示一个图片就占了一个LinkedBlockingQueue的大小。当有128张需要显示的时候。整个队列就满了，在加载下一个的时候就会抛出上面的这个异常。如果你慢慢的滑动理论上是不会出现这个问题的，但是凭借我20多年单身的手速，几下就异常了，所以我灵机一动直接在128后面加了一个0，做了一个1280的阻塞队列，现在应该没问题了吧，于是，我找来了pad和比我手速还快的小伙伴测试，没问题的。这就证明了，这个异常抛出的原因一般就是队列任务已满，需要检查你的阻塞队列的大小。

ok，总结一下ThreadPoolExecutor执行任务的一个流程，

if(任务线程>=核心线程){
    if(任务线程>=最大线程){
        if(任务线程>=阻塞线程){
            抛出java.util.concurrent.RejectedExecutionException
        }else{
            正常执行
        }
    }else{
        正常执行
    }
}else{
    正常执行
}

其实大家经常使用的AsyncTask也配置了一个线程池，源码的开头如下：

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE = 1;

    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

    /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

结合之前我解释的构造函数的参数和AsyncTask的源码，我们可知：
核心线程数=CPU核心数+1；
线程池最大线程数=CPU核心数*2+1；
由于没有设置allowCoreThreadTimeOut，所以核心线程无超时机制；
KEEP_ALIVE=1，单位：秒，所以非核心线程超时时间为1S；
任务队列的容量是128；
大概就是这样，我觉得我们自定义的时候按照源码的格式来比较好。

2、FixedThreadPool
创建方式入下：

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

特点：线程数量固定，空闲不会被回收，更快的响应速度，无超时机制，无大小限制。
用途：比如需要大量长时间面向连接的线程时。（Thinking in Java说的）

3.CachedThreadPool
创建方式入下：

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

特点：只有最大线程数为int的最大值。超时时间为60秒。当整个线程池都出去闲置状态 超过60秒的时候，会被回收，几乎不占用任何系统资源。
用途：适合执行大量的耗时较少的任务。

4.ScheduledThreadPool
创建方式入下：

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

特点：核心数量固定，非核心数量无限制，非核心线程闲置时立即被回收。
用途：执行定时任务和具有固定周期的重复任务。

5.SingleThreadExecutor
创建方式入下：

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

特点：只有一个核心线程。
用途：统一所有的外界任务到一个线程中，这是得所有的任务之间不需要考虑线程同步。

三、线程池优点。
1.重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。
2.能有效的控制线程池的最大并发数，避免大量的线程之间因为互相抢占系统资源而导致的阻塞现象。
3.能够对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能。

总结，上面已经对线程池做了一个详细的讲解，现在总结一下他们的关系。这里举一个例子，最近去逛车展，看到很多新车，这里加入Executor就是大众，那么他旗下的高尔夫7，奥迪A3，明锐，迈腾之类的就是FixedThreadPool—CachedThreadPool—ScheduledThreadPool—SingleThreadExecutor这四个线程池，他们各司其职，有的车适合家用，有的车适合操控，有的体面等等，而，ThreadPoolExecutor就相当于MQB平台，通过这个平台可以生产出上面的汽车。假如有一天大众把MQB平台卖给宝马，那么宝马有可能给他装上一台V12的发动机调教成一台超跑。上一句的话翻译成线程池就是Executor把ThreadPoolExecutor卖给了开发者，让他们去自定义。那么如何自定义就是调教不同的参数，让它成为为你效劳的线程池。

最后推荐一篇文章，非常非常的形象，以第一视角讲解线程，附上简介地址，
我是一个线程
再来一篇微信的文章，挺全面的。
这篇文章有点长