Android 多线程编程 - 线程池

前言

在编程中经常会使用线程来异步处理任务，但是每个线程的创建和销毁都需要一定的开销。如果每次执行一个任务都需要开一个新线程去执行，则这些线程的创建和销毁将消耗大量的资源；并且线程都是“各自为政”的，很难对其进行控制，更何况有一堆的线程在执行。这时就需要线程池来对线程进行管理。在Java1.5中提供了Executor框架用于任务的提交和执行解耦，任务的提交交给Runnable或者Callable，而Executor框架用来处理任务。Executor框架中最核心的成员是ThreadPoolExecutor，它是线程池的核心实现类。

1. ThreadPoolExecutor

可以通过ThreadPoolExecutor来创建一个线程池，ThreadPoolExecutor类一共有4个构造方法。其中，拥有参数最多的构造方法如下所示：

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

这些参数的作用如下：

• corePoolSize：核心线程数。默认情况下线程池是空的，只有任务提交时才会创建线程。如果当前运行的线程数少于corePoolSize，则创建新线程来处理任务；如果当前运行的线程数等于或者多于corePoolSize，则不再创建创建新线程。如果调用线程池的prestartAllCoreThread方法，则线程池会提前创建并启动所有的核心线程来等待任务。

• maximumPoolSize：线程池允许创建的最大线程数。如果任务队列满了，并且线程数小于maximumPoolSize时，则线程池仍旧会创建新的线程来处理任务。

• KeepAliveTime：非核心线程闲置的超时时间。超过这个时间，非核心线程会被回收。如果任务很多，并且每个任务的执行时间很短，则可以调大KeepAliveTime来提高线程的利用率。另外，如果设置allowCoreThreadTimeOut属性为true时，KeepAliveTime也会应用到核心线程上。

• TimeUnit：KeepAliveTime参数的时间单位。可选单位有天（DAYS）、小时（HOURS）、分钟（MINUTES）、秒（SECONDS）、毫秒（MILLISECONDS）等。

• workQueue：任务队列。如果当前线程数大于corePoolSize，则将任务添加到此任务队列中。该任务队列是BlockingQueue类型的，也就是阻塞队列。

• ThreadFactory：线程工厂。可以用线程工厂给每个创建出来的线程设置名字。一般情况下无须设置该参数。

• RejectedExecutionHandler：饱和策略。这是当任务队列和线程池都满了时，所采取的应对策略。默认是AbortPolicy，表示无法处理新任务，并抛出RejectedExecutionException异常。此外还有3种策略：

• CallRunsPolicy：用调用者所在的线程来处理任务。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。

• DiscardPolicy：不能执行的任务，并将该任务删除。

• DiscardOldPolicy：丢弃队列最近的任务，并执行当前的任务。

2. 线程池的处理流程和原理

线程池的处理流程主要分为3个步骤，如下所示：

1. 提交任务后，线程池先判断线程数是否到达了核心线程数（corePoolSize）。如果未到达核心线程数，则创建核心线程处理任务；否则执行下一步操作。

2. 接着线程池判断任务队列是否满了。如果没满，则将任务添加到任务队列中；否则就执行下一步操作。

3. 这时，因为任务队列满了，所以线程池就判断线程数是否达到了最大线程数。如果未达到最大线程数，则创建非核心线程处理任务。否则，就执行饱和策略，默认会抛出RejectedExecutionException异常。

补充：线程池的空闲线程会不断从任务队列中取出任务进行处理。

3. 线程池的种类

通过直接或者间接的配置ThreadPoolExecutor的参数可以创建不同类型的ThreadPoolExecutor，其中有4种线程池比较常用，它们分别是FixedThreadPool、CachedThreadPool、SingleThreadExecutor和SechduledThreadPool。

3.1. FixedThreadPool

FixedThreadPool是可重用固定线程数的线程池。在Executors类中提供了创建FixedThreadPool的方法，如下所示：

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

FixedThreadPool的corePoolSize和maximumPoolSize都设置为创建FixedThreadPool指定的参数nThreads，也意味着FixedThreadPool只有核心线程，并且数量是固定的，没有非核心线程。keepAliveTime设置为0L意味着多余线程会被立即终止。因为不会产生多余线程，所以keepAliveTime是无效的参数。另外，任务队列采用了无界阻塞队列LinkedBlockingQueue（容量默认为Integer.MAX_VALUE）。

3.2. CachedThreadPool

CachedThreadPool是一个根据需要创建线程的线程池，创建CachedThreadPool的代码如下：

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

CachedThreadPool的corePoolSize为0，maximumPoolSize设置为Integer.MAX_VALUE，这意味着CachedThreadPool没有核心线程，非核心线程是无界的。keepAliveTime设置为60L，则空闲线程等待新任务的最长时间为60s。在此用了阻塞队列SynchornousQueue，它是一个不存储元素的阻塞队列，每个插入操作必须等待另一个线程的移除操作，同样任何一个线程的移除操作都等待另一个线程的插入操作。

当执行executor方法时，首先会执行SynchronousQueue方法的offer方法来提交任务，并且查询线程池中是否有空闲的线程执行SynchronousQueue的pol方法来移除任务。如果有则配对成功，将任务交给这个空闲的线程处理；如果没有，则配对失败，创建新的线程去处理任务。当线程池中的线程空闲时，它会执行SynchoronousQueue的poll方法，等待SynchronousQueue中新提交的任务。如果超过60s没有新任务提交到SynchronousQueue，则这个空闲线程将终止。因为maximumPoolSize是无界的，所以如果提交的任务大于线程池中线程处理任务的速度，就会不断创建新线程。另外，每次提交任务都会立即有线程去处理。所以，CachedThreadPool比较适于大量的需要立即处理并且耗时较少的任务。

3.3. SingleThreadExecutor

SingleThreadExecutor是使用单个工作线程的线程池，其创建源码如下所示：

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

corePoolSize和maximumPoolSize都为1，意味着SingleThreadExecutor只有一个核心线程，其他的参数都和FixedThreadPool一样，这里就不赘述了。

当执行execute方法时，如果当前运行的线程数未达到核心线程数，也就是当前没有运行的线程，则创建一个新线程来处理任务。如果当前有运行的线程，则将任务添加到阻塞队列LinkedBlockingQueue中。因此，SingleThreadQueue能确保所有的任务在一个线程中按照顺序逐一执行。

3.4. ScheduledThreadPool

ScheduledThreadPool是一个能实现定时和周期性任务的线程池，它的创建源码如下所示：

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

• 这里创建了ScheduledThreadPoolExecutor，ScheduledThreadPoolExecutor继承自ThreadPoolExecutor，它主要用于在给定延时之后运行任务或者定期处理任务。ScheduledThreadPollExecutor的构造方法如下：

    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, 2147483647, 10L, TimeUnit.MILLISECONDS,
             new ScheduledThreadPoolExecutor.DelayedWorkQueue());
    }

从上面的代码可以看出，ScheduledThreadPoolExecutor的构造方法最终调用的是ThreadPoolExecutor的构造方法。corePoolSize是传进来的固定数值，maximumPoolSize的值是Integer.MAX_VALUE。因为这里采用的DelaydWorkQueue是无界的，所以maximumPoolSize这个参数是无效的。

当执行SecheduledThreadPoolExecutor的scheduleAtFixedTRate或者schedueWithFixedDelay方法时，会向DelayedWorkQueue添加一个实现RunnableScheduledFuture接口的ScheduledFutureTask（任务的包装类），并会检查运行的线程数是否达到了corePoolSize（核心线程数）。如果没有达到，则新建线程并启动它，但并不是立即去执行任务，而是去DelayedWorkQueue中取ScheduledFutureTask，然后执行任务。如果运行的线程数达到了corePoolSize时，则将任务添加到DelayedWorkQueue中。DelayedWorkQueue会将任务进行排序，先要执行的任务放在队列的前面。其跟此前介绍的线程池不同的是，当执行完任务后，会将ScheduledFutureTask中的time变量改为下次要执行的时间并放回DelayedWorkQueue中。

最后

如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。

相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。

欢迎大家一键三连支持，若需要文中资料，直接扫描文末CSDN官方认证微信卡片免费领取↓↓↓

PS:群里还设有ChatGPT机器人，可以解答大家在工作上或者是技术上的问题