在操作系统中，线程是操作系统调度的最小单位，同时线程又是一种受限的系统资源，即线程不可能无限地产生，并且线程的创建和销毁都会有相应的开销。所以就有了线程池的引入，它可以避免因为频繁创建和销毁线程所带来的系统开销。Android中的线程来源于java，主要是通过Executor来派生特定的线程池。
优点：
(1).重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。
(2).能有效地控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致的阻塞现象。
(3).能够对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能。
Executor接口的真正实现为ThreadPoolExecutor，通过配置它的参数可以创建各种线程池。在介绍线程池的种类之前，先需要介绍下该类中每个参数的作用。
ThreadPoolExecutor
它有几种构造函数提供我们实例化，看它参数最多的构造方法
//七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
- 1.核心线程 corePoolSize
线程池新建线程时，如果当前线程总数小于核心线程 corePoolSize，则新建核心线程，如果超过corePoolSize，则新建非核心线程。
核心线程默认是一直在存活在线程池中，即使处于闲置状态。
如果指定 ThreadPoolExecutor 的 allowCoreThreadTimeOut 这个属性为 true，那么核心线程如果处于闲置状态的话，超过一定时间(keepAliveTime)，就会被销毁掉。
- 2.线程总数 maximumPoolSize
线程中的最大线程数，等于核心线程加上非核心线程。
- 3.超时时间 keepAliveTime
非核心线程超时时长，一个非核心线程的闲置时间超过这个线程设置的时长，就会被销毁。同时如果设置allowCoreThreadTimeOut = true，则会作用于核心线程。
- 4 . 时间单位
keepAliveTime 的时间单位 TimeUnit ，枚举值，有以下几种：
NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
MILLISECONDS ： 1毫秒 = 1秒 /1000
SECONDS ： 秒
MINUTES ： 分
HOURS ： 小时
DAYS ： 天
- 5 . 队列 BlockingQueue
它是一个接口，代表一个任务队列，维护着等待执行的runnable, 当所有的核心线程创建之后，就会将待执行的任务存入任务队列，如果任务队列满了，则创建非核心线程，根据具体的实现，有不同的使用情形，下面是常用的任务队列实现。
SynchronousQueue 任务队列接受任务时，把任务直接提交给线程处理，如果所有线程都在工作，那就新创建一个线程来处理，所以此种任务队列一般需要设置maximumPoolSize为 Integer.MAX_VALUE，以防出现不能新建线程产生错误。
LinkedBlockingQueue 任务队列接受任务时候，如果当前线程数小于核心线程数，则新建核心线程处理任务，如果当前线程数等于核心线程数，则进入队列等待，由于这个任务队列没有最大值限制，则所有超过核心线程都会被添加到队列中，这也就导致了maximumPoolSize 的设定失效，线程总数不会超过corePoolSize
ArrayBlockingQueue 限定任务队列的长度，接受到任务时候，如果没有达到corePoolSize 的值，则新建核心线程执行任务，如果已经达到了，则入队列等待，如果队列已经满了，则新建非核心线程执行任务，如果线程总数达到了maximumPoolSize，则发生错误
DelayQueue 队列内元素必须实现Delayed 接口，这就表示你传进去的任务必须实现Delayed 接口，入队列的元素，首先会先入队列，只有达到了指定的延时时间，才会执行任务
- 6 . ThreadFactory
创建线程的方式，Executors 有默认的ThreadFactory创建方式，一般没有特别需求可以直接使用它的默认实现方式，提交的任务通过它创建线程
/**
* The default thread factory.
*/
private static class DefaultThreadFactory implements ThreadFactory {
...
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}
- 7 . RejectedExecutionHandler
抛出异常专用，也就是线程池的饱和策略，ThreadPoolExecutor 实现了几种常用异常
ThreadPoolExecutor.AbortPolicy:默认的策略，丢弃任务并抛出RejectedExecutionException异常，这种策略需要加try catch，否则程序会直接退出
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常，空方法。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）。
ThreadPoolExecutor.CallerRunsPolicy在调用execute的线程里面执行此策略，会阻塞入口
用户自定义饱和策略（最常用）
实现RejectedExecutionHandler，并自己定义策略模式
关于线程池详细源码分析以及使用过程，可以看这篇文章
常见的四种线程池
Executors默认给我们提供了几种线程池，常用的有四种，都是通过ThreadPoolExecutor 直接或者间接实现的，调用者可以很方便的使用它
- 1 . CachedThreadPool
创建方法：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
好处：
1.线程无限制
2.有空闲线程则复用空闲线程，若无空闲线程则新建线程
3.一定程序减少频繁创建/销毁线程，减少系统开销
- 2 .FixedThreadPool
创建方法：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
只有核心线程，线程总数是一定的
好处：
1.可控制线程最大并发数（同时执行的线程数）
2.超出的线程会在队列中等待
- 3 . ScheduledThreadPool
创建方法：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize,
ThreadFactory threadFactory) {
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue(), threadFactory);
}
好处：
1 . 这个线程池支持定时或者周期性任务
- 4 . SingleThreadExecutor
创建方法：
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
好处：
1.有且仅有一个工作线程执行任务
2.所有任务按照指定顺序执行，即遵循队列的入队出队规则
关于这几种线程池的原理，可以看这篇文章
Android中线程池的使用
作为一名Android开发者，在平时我们开发中，使用的原生API或者第三方库，都会或多或少使用线程池，下面举出几个我在平时开发中使用到线程池的地方。
- 1 . EventBus中线程池的使用
熟悉EventBus源码的人都会知道，它里面有三个Poster，不熟悉的看这里，它在EventBus中起到一个线程切换的作用，同时也提供一个线程去执行异步任务。其中它们的默认使用如下
private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();
可以看见创建了一个CachedThreadPool，这个线程池都是非核心线程，可以在一定程度上减轻频繁创建线程所带来的线程开销。
- 2 . Okhttp中线程池的使用
在Okhttp中有个分发器Dispatcher，在里面维护了一个executorService，它的创建如下：
public synchronized ExecutorService executorService() {
if (executorService == null) {
executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
}
return executorService;
}
它是完全自定义的ThreadPoolExecutor，可以看见它的核心线程为0，非核心线程设置为
Integer.MAX_VALUE 和和EventBus的线程数一样
- 3 . AsyncTask中线程池的使用
刚学Android的时候，这个AsyncTask 作为异步任务的API 用得还是比较广的，它里面封装了线程池和Handler，在异步任务和UI线程中切换非常方便，看下其线程池的使用
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());
}
};
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
}
它的核心线程是Math.max(2, Math.min(CPU_COUNT - 1, 4))， 也就是最少是两个，CPU_COUNT 是CPU的数，总线程总数是CPU_COUNT * 2 + 1，而它的任务队列是new LinkedBlockingQueue<Runnable>(128)，这样它的任务队列的最大长度是128。这样就达到了控制线程的并发数，当线程达到最大核心线程数时候，其它任务就会被放到任务队列中。
还有很多地方也用到了线程池，就不一一举例了。
参考文档
1 . 详解 Java 线程池
2 . Android开发者探索
3 . Android开发者进阶
4 . Java线程池(ThreadPoolExecutor)原理分析与使用
5 . Java线程Executor框架详解与使用
