每个 Android 应用进程在创建时，会同时创建一个线程，我们称之为主线程，负责更新 UI 界面以及和处理用户之间的交互，因此，在 Android 中，我们又称之为 UI 线程。一个进程中 UI 线程只有一个，为了不造成界面卡顿、提高用户体验，我们势必要将一些耗时操作交由子线程来执行。
使用子线程的方式主要分两种：


直接使用 Thread 和 Runnable 等创建子并使用线程


使用线程池创建并使用子线程


线程池是什么
线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新创建一个线程。线程池中线程的数量通常完全取决于可用内存数量和应用程序的需求；每个线程都有被分配一个任务，一旦任务完成了，线程回到池子中并等待下一次分配任务。 
一般情况下，推荐使用线程池来创建和使用子线程，不建议使用第一种方式。
为何要用线程池
上面说了，在 Android 开发过程中，建议使用线程池来创建和使用子线程，那么使用线程池的好处有哪些呢？


线程池改进了一个应用程序的响应时间。由于线程池中的线程已经准备好且等待被分配任务，应用程序可以直接拿来使用而不用新建一个线程。


线程池节省了 CLR 为每个短生存周期任务创建一个完整的线程开销并可以在任务完成后回收资源。


线程池根据当前在系统中运行的进程来优化线程片。


线程池允许我们开启多个任务而不用为每个线程设置属性。


线程池允许我们为正在执行的任务的程序参数传递一个包含状态信息的对象引用。


线程池可以用来解决处理一个特定请求最大线程数量限制问题。


系统分配给每个应用的线程栈是固定的，使用线程池可以有效地避免线程栈溢出引起的应用崩溃。


Android 中的线程池
Android 中线程池的真正实现是 ThreadPoolExecutor，其构造方法有 5 个，通过一系列参数来配置线程池。下面介绍一个比较常用的构造方法及其参数的含义。

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)

?


参数
含义


corePoolSize
int: 线程池的核心线程数，默认情况下，核心线程回一直在线程池中存活，即使他们处于闲置状态。如果将?allowCoreThreadTimeOut?的属性设置为 true，那么闲置的核心线程在等待新任务到来时会有超时策略，这个时间间隔由 keepAliveTime 所指定，当等待时间超过 keepAliveTime 所指定的时长后，核心线程就会被终止。


maximumPoolSize
int: 线程池中允许的线程最大数量，当活动线程达到这个数值后，后续的新任务会被阻塞。int: 线程池中允许的线程最大数量，当活动线程达到这个数值后，后续的新任务会被阻塞。


keepAliveTime
long: 非核心线程闲置时的超时时长，超过这个时长，非核心线程就会被回收。当?allowCoreThreadTimeOut?属性被设置为 true 时，该参数同样会作用于核心线程。


unit
TimeUnit: keepAliveTime 参数的时间单位 ，参数为?TimeUnit?的枚举，常见的有?TimeUnit.MILLISECONDS(毫秒)、TimeUnit.SECOND(秒) 等。


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


threadFactory
ThreadFactory: 创建线程的线程工厂。ThreadFactory?是一个接口，只有一个方法：Thread newThread (Runnable r)



?
?


Throws?



IllegalArgumentException

符合以下任一条件，则抛出此异常:
 corePoolSize < 0 
keepAliveTime < 0 
maximumPoolSize <= 0 
maximumPoolSize < corePoolSize



NullPointerException
当 workQueue 或者 threadFactory 为 null 时，抛出此异常。



 ThreadPoolExecutor 执行任务时大致遵循如下规则：


如果线程池中的线程数量未达到核心线程的数量，那么会直接启动一个核心线程来执行任务。


如果线程池中的线程数量已经达到或超过核心线程的数量，那么任务会被插入到任务队列中等待执行。


如果步骤 2 中无法将任务插入到任务队列，则表示任务队列已满。此时，如果线程数量未达到 maximumPoolSize 值，则会立即启动一个非核心线程来执行任务。


如果步骤 3 中线程数量大于或等于 maximumPoolSize 值，则拒绝执行次任务，此时 ThreadPoolExecutor 会调用 RejectedExecutionHandler 的 rejectedExecution 来通知调用者。



RejectedExecutionHandler 是线程池持有的一个对象，用于不能由 ThreadPoolExecutor 执行的任务的处理 

Android 中线程池的类型及区别
Android 中最常见线程池有四种，分别是：FixedThreadPool、CacheThreadPool、ScheduledThreadPool 以及 SingleThreadPool，它们都直接或间接的通过配置 ThreadPoolExecutor 来实现自己的功能特性。
1. FixedThreadPool
线程数量固定的线程池，通过 Executors 的 newFixedThreadPool 方法创建。有两个重载的创建方法：

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


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

除非线程池被关闭，否则线程不会被回收，即时线程处于空闲状态。如果在所有线程都处于活动状态时提交额外的任务，它们将在队列中等待，直到有一个线程可用为止。由创建方法可知，FixedThreadPool 只有核心线程并且这个核心线程没有超时机制（keepAliveTime 参数为 0L），加上线程不会被回收，因此使用此类线程池可以快速地响应外界的请求。
2. CacheThreadPool
线程数量不定的线程池，通过 Executors 的 newCachedThreadPool 方法创建。有两个重载的创建方法：

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

CacheThreadPool 有以下个特征：


没有核心线程（ corePoolSize 参数为 0 ），只有非核心线程且非核心线程的数量为 Integer.MAX_VALUE，这就相当于非核心线程的数量可以无限大。 


线程池的线程处于空闲状态时，线程池会重用空闲的线程来处理新任务，否则创建新的线程来处理，新创建的线程会添加到线程池中。这将提高执行许多短期异步任务的程序性能。


闲置时间超过 60 秒的空闲线程会被回收（keepAliveTime 参数为 60L ）。因此，闲置时间足够长的 CacheThreadPool 也不会消耗任何系统资源。


3. ScheduledThreadPool
核心线程数量固定，非核心线程数量不定的线程池，通过 Executors 的 newscheduledthreadpool 方法创建。有两个重载的创建方法：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

public static ScheduledExecutorService newScheduledThreadPool(
        int corePoolSize, ThreadFactory threadFactory) {
    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}

ScheduledThreadPool 相比较其他三种线程池，有特殊性，由 ScheduledThreadPoolExecutor 实现， newscheduledthreadpool 方法也是通过创建 ScheduledThreadPoolExecutor 的实例来完成线程池的创建，代码如下：

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

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

由 ScheduledThreadPoolExecutor 的构造函数可知， ScheduledThreadPool 的核心线程数量是固定的，由传入的 corePoolSize 参数决定，非核心线程数量可以无限大。非核心线程闲置回收的超时时间为 10秒（ DEFAULT_KEEPALIVE_MILLIS 的值为 10L ）。这类线程主要用于执行定时任务或者具有周期性的重复任务。
4. SingleThreadPool
只有一个核心线程，通过 Executors 的 newsinglethreadexecutor 方法创建。有两个重载的创建方法：

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

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(/* corePoolSize*/ 1, /* maximumPoolSize*/ 1,
                                /* keepAliveTime*/ 0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory));
}

SingleThreadPool 由 代理类 FinalizableDelegatedExecutorService 创建。该线程池只有一个线程（核心线程），并且该线程池的任务队列是无上限的，这就确保了所有的任务都在同一个线程中顺序执行。

注意，如果由于在执行期间出现故障而导致该线程终止，那么如果需要执行后续任务，则新线程将取而代之。

四类线程池的区别
上面分别对 Android 中常见的 4 种线程池进行了简单的介绍，除了这 4 种系统提供的线程池外，我们在使用的过程中，也可以根据需要直接通过 ThreadPoolExecutor 的构造函数来灵活的配置线程池。那么，上述的 4 种线程池，其区别在哪呢？了解其区别有助于我们去选择更为合适的线程池或者直接通过 ThreadPoolExecutor 来配置更灵活的线程池。
FixedThreadPool 线程固定，且不会被回收，能够更快的响应外界请求。
CachedThreadPool 只有非核心线程，且线程数相当于无限大，任何任务都会被立即执行。比较适合执行大量的耗时较少的任务。
ScheduledThreadPool 主要用于执行定时任务或者具有周期性的重复任务。
SingleThreadPool 只有一个核心线程，确保所有任务都在同一线程中按顺序完成。因此不需要处理线程同步的问题。 

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标移动开发之Android频道！