线程池android,线程池七大核心参数

第十一章 Android的线程和线程池

执行AsyncTask的execute方法，会执行executeOnExecutor方法，该方法第一个参数是线程池，第二个是传给AsyncTask的参数

在该方法里，首先会调用onPreExecute方法，然后将传进来的参数赋值给mWorker.params，再调用第一个参数线程池的execute方法，传入mFuture

如果是AsyncTask的默认线程池SerialExecutor，则只是用于排队，使AsyncTask提交的任务一个一个的执行。最终执行是放在THREAD_POOL_EXECUTER线程池中执行的

执行mFuture的run方法，最终调用mWorker对象的call方法，在call方法里，会执行doInBackground方法，返回一个Result对象，传入postResult方法里

在postResult方法里，会利用sHandler即主线程的handler把Result发送到主线程进行处理，在handler的handMessage方法中，会调用onPostExecute方法，将结果发送到主线程

如果需要更新进度，可在doInBackground方法里调publishProgress方法，传入进度信息，publishProgress方法里就会通过sHandler把进度信息传到主线程

相关问答

Q1: Android线程池的使用

在Android中有主线程和子线程的区分。主线程又称为UI线程，主要是处理一些和界面相关的事情，而子线程主要是用于处理一些耗时比较大的一些任务，例如一些网络操作，IO请求等。如果在主线程中处理这些耗时的任务，则有可能会出现ANR现象（App直接卡死）。

线程池，从名字的表明含义上我们知道线程池就是包含线程的一个池子，它起到新建线程、管理线程、调度线程等作用。

既然Android中已经有了线程的概念，那么为什么需要使用线程池呢？我们从两个方面给出使用线程池的原因。

在Android中线程池就是ThreadPoolExecutor对象。我们先来看一下ThreadPoolExecutor的构造函数。

我们分别说一下当前的几个参数的含义：

第一个参数corePoolSize为 核心线程数 ，也就是说线程池中至少有这么多的线程，即使存在的这些线程没有执行任务。但是有一个例外就是，如果在线程池中设置了allowCoreThreadTimeOut为true，那么在 超时时间（keepAliveTime） 到达后核心线程也会被销毁。

第二个参数maximumPoolSize为 线程池中的最大线程数 。当活动线程数达到这个数后，后续添加的新任务会被阻塞。

第三个参数keepAliveTime为 线程的保活时间 ，就是说如果线程池中有多于核心线程数的线程，那么在线程没有任务的那一刻起开始计时，如果超过了keepAliveTime，还没有新的任务过来，则该线程就要被销毁。同时如果设置了allowCoreThreadTimeOut为true，该时间也就是上面第一条所说的 超时时间 。

第四个参数unit为 第三个参数的计时单位 ，有毫秒、秒等。

第五个参数workQueue为 线程池中的任务队列 ，该队列持有由execute方法传递过来的Runnable对象（Runnable对象就是一个任务）。这个任务队列的类型是BlockQueue类型，也就是阻塞队列，当队列的任务数为0时，取任务的操作会被阻塞；当队列的任务数满了（活动线程达到了最大线程数），添加操作就会阻塞。

第六个参数threadFactory为 线程工厂 ，当线程池需要创建一个新线程时，使用线程工厂来给线程池提供一个线程。

第七个参数handler为 拒绝策略 ，当线程池使用有界队列时（也就是第五个参数），如果队列满了，任务添加到线程池的时候的一个拒绝策略。

可以看到FixedThreadPool的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出FixedThreadPool的几个特点：

可以看到CacheThreadPool的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出CacheThreadPool的几个特点：

可以看到ScheduledThreadPoolExecutor的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出ScheduledThreadPoolExecutor的几个特点：

可以看到SingleThreadExecutor的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出SingleThreadExecutor的几个特点：

Q2: Android 线程池的封装

GlobalThreadPools.java：

调用：

线程池

线程池概念来源于Java中的Executor,它是一个接口，真正的实现为ThreadPoolExecutor。ThreadPoolExecutor提供了一系列参数来配置线程池。

优点

1：重用线程池中的线程，线程在执行完任务后不会立刻销毁，而会等待另外的任务，这样就不会频繁地创建、销毁线程和调用GC。。

2：有效控制线程池的最大并发数，避免大量线程抢占资源出现的问题。

3：对多个线程进行统一地管理，可提供定时执行及指定间隔循环执行的功能。

ThreadPoolExecutor 有多个重载方法，但最终都调用了这个构造方法

public ThreadPoolExecutor(int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueueRunnable workQueue,

ThreadFactory threadFactory,

RejectedExecutionHandler handler)

参数：

corePoolSize：线程池中核心线程的数量；为了内存优化，在线程池维护了几个重要的线程，不达到一定条件不开辟其余线程

maximumPoolSize ：线程池中最大线程数量：这个数量是包括核心线程的，当线程池中的正在执行的线程池达到了这个数字，再提交线程如果你不做特殊处理将会抛出异常

keepAliveTime：非核心线程的超时时长；当线程池中的非核心线程闲置时间超过这个值代表的时间后，将会被回收；同时如果调用ThreadPoolExecutor.allowCoreThreadTimeOut(true)，那么核心线程也会符合这个设置

unit：keepAliveTime值的单位，可以是时分秒等

workQueue：存放待执行的线程；你通过execute方法提交线程，但是这些线程还没达到执行条件，那么就会保存在这个队列里

threadFactory：创建线程池的工厂；在这个工厂里，我们可以指定线程的一些信息

handler：线程提交拒绝策略；通常是线程池中的正在执行的线程数量已经达到了最大线程数或线程池关闭，如果不传，默认是抛出一个RejectedExecutionException，所以最好传下

推荐使用 Executors 的工厂方法来创建线程池，通过直接或间接的配置 ThreadPoolExecutor 的参数来构建线程池，常用的线程池有如下 4 种，newFixedThreadPool ，newCachedThreadPool，

newScheduledThreadPool 和 newSingleThreadExecutor。

ThreadPoolExecutor 执行任务时大致遵循如下流程：

1.如果线程池中的线程数未达到核心线程数，则会立马启用一个核心线程去执行。

2.如果线程池中的线程数已经达到核心线程数，且任务队列workQueue未满，则将新线程放入workQueue中等待执行。

3.如果线程池中的线程数已经达到核心线程数但未超过线程池规定最大值，且workQueue已满，则开启一个非核心线程来执行任务。

4.如果线程池中的线程数已经超过线程池规定最大值，则拒绝执行该任务，采取饱和策略，并抛出RejectedExecutionException异常。

线程池大小：（N为CPU数量）

如果是CPU密集型应用，则线程池大小设置为N+1

如果是IO密集型应用，则线程池大小设置为2N+1

I/O密集型

指的是系统的CPU效能相对硬盘/内存的效能要好，大部分的状况是 CPU 在等 I/O (硬盘/内存) 的读/写， CPU Loading 不高。

CPU密集型

指的是系统的 硬盘/内存 效能 相对 CPU 的效能 要好，大部分的状况是 CPU Loading 100%，CPU 要读/写 I/O (硬盘/内存)，I/O在很短的时间就可以完成，而 CPU 还有许多运算要处理，CPU Loading 很高。

获取CPU数量的方法为：

Runtime.getRuntime().availableProcessors();

摘自：

Q3: Android中的线程池

 线程池的好处

1、重用线程池中的线程，避免线程的创建与销毁带来的性能开销

2、能有效控制线程池的最大并发数，避免大量线程因抢占资源而导致的阻塞

3、能对线程进行简单的管理，提供定时或者指定间隔时间、循环执行等操作

线程池的概率来自于java的Executor接口，实现类是ThreadPoolExecutor, 它提供一系列的参数来配置线程池，以此构建不同的线程池。Android的线程池分4类，都是通过Executors所提供的工厂方法来得到。

ThreadPoolExecutor有四个构造函数，下面这个是最常用的

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueueRunnnable workQueue, ThreadFactory threadFactory)

corePoolSize

线程池中的核心线程数，默认情况下核心线程会在线程池中一直存活，即使他们处于闲置状态。如果设置ThreadPoolExecutor 中的allowCoreThreadTimeOut = true, 核心线程在等待新任务到来时有超时机制，时间超过keepAliveTime所指定的时间后，核心线程会终止。

maximumPoolSize

最大线程数

keepAliveTime

非核心线程闲置的超时时间，超过这个时间，非核心线程会被回收。核心线程则要看allowCoreThreadTimeOut属性的值。

unit

时间单位

workQueue

线程池中的工作队列

threadFactory

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

举个例子，我们常用的okhttp内部也是使用了线程池，它的ThreadPoolExecutor主要是定义在Dispatcher类里面。 使用的是CachedThreadPool。

executorService = ThreadPoolExecutor(0, Int.MAX_VALUE, 60, TimeUnit.SECONDS, SynchronousQueue(), ThreadFactory("okhttp Dispatcher", false))

1、FixedThreadPool

通过Executors的newFixedThreadPool（）创建，这是一个线程数量固定的线程池，里面所有的线程都是核心线程。

public static ExecutorService newFixedThreadPool(int nThreads){

return new ThreadPoolExecutor(nThreads, nThreads, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueueRunnable())

}

2、CachedThreadPool

通过Executors的newCacheThreadPool（）创建，这是一个线程数量不定的线程池，里面所有的线程都是非核心线程。最大线程数是无限大，当线程池中的线程都处于活动状态时，新的task会创建新的线程来处理，否则就使用空闲的线程处理，所有的线程都是60s的超时时间，超时后会自动回收。

public static ExecutorService newFixedThreadPool(){

return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueueRunnable())

}

3、ScheduledThreadPool

通过Executors的newScheduledThreadPool（）创建, 核心线程固定，非核心线程无限大，当非核心线程空闲时，会立即被回收。适合做定时任务或者固定周期的重复任务。

public static ExecutorService newScheduledThreadPool(int corePoolSize){

return new ThreadPoolExecutor(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new DelayedWorkQueue())

}

4、SingleThreadExcecutor

通过Executors的newSingleThreadPool（）创建，内部只有一个核心线程。

public static ExecutorService newFixedThreadPool(){

return new ThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueueRunnable())

}

课外知识：LinkedBlockingQueue

LinkedBlockingQueue是由链表组成的阻塞队列，内部head 指向队列第一个元素，last指向最后一个元素。入队和出队都会加锁阻塞，都是使用了不同的锁。

DelayedWorkQueue

延时队列，队内元素必须是Delayed的实现类。对内元素会按照Delayed时间进行排序，对内元素只有在delayed时间过期了才能出队。

入队的时候不阻塞队列，出队的时候，如果队列为空或者队列里所有元素都等待时间都没有到期，则该线程进入阻塞状态。

Q4: Android中的线程和线程池

一、除了Thread外，扮演线程角色的还有：AsyncTask和IntentService，同时HandlerThread也扮演特殊的线程。

      IntentService：内部采用HandlerThread来执行，像一个后台线程，同时是一个服务，不容易被系统杀死。

二、HandlerThread的run方法是一个无限循环

三、IntentService中任务是排队执行的

四、AsyncTask 

1、Android1.6之前串行执行任务，1.6时候采用线程池里的并行，Android3.0开始又开始串行（为了避免并发错误），单任可以并行。

2、AsyncTask必须在UI线程调用（不过这个不是绝对的，和版本有关系，API 16之前，API 16到 22， API 22以后） 参考一

原因：内部有静态Handler，采用UI线程的Looper来处理消息，这就是为什么AsyncTask必须在UI线程调用，因为子线程默认没有Looper无法创建下面的Handler，程序会直接Crash

3、AsyncTask中有两个线程池和一个Handler，一个线程池用于任务排队，一个线程池用于真正的执行任务，InternalHandler用于将

执行环境从线程池切换到主线程

AsyncTask串行与并行

五、线程池

线程池中多余的线程是如何回收的

Q5: Android线程池ThreadPoolExecutor详解

       传统的多线程是通过继承Thread类及实现Runnable接口来实现的，每次创建及销毁线程都会消耗资源、响应速度慢，且线程缺乏统一管理，容易出现阻塞的情况，针对以上缺点，线程池就出现了。

       线程池是一个创建使用线程并能保存使用过的线程以达到复用的对象，简单的说就是一块缓存了一定数量线程的区域。

       1.复用线程：线程执行完不会立刻退出，继续执行其他线程；

       2.管理线程：统一分配、管理、控制最大并发数；

       1.降低因频繁创建销毁线程带来的性能开销，复用缓存在线程池中的线程；

       2.提高线程执行效率响应速度，复用线程：响应速度；管理线程：优化线程执行顺序，避免大量线程抢占资源导致阻塞现象；

       3.提高对线程的管理度；

       线程池的使用也比较简单，流程如下：

       接下来通过源码来介绍一下ThreadPoolExecutor内部实现及工作原理。

       线程池的最终实现类是ThreadPoolExecutor，通过实现可以一步一步的看到，父接口为Executor:

       其他的继承及实现关系就不一一列举了，直接通过以下图来看一下：

       从构造方法开始看：

       通过以上可以看到，在创建ThreadPoolExecutor时，对传入的参数是有要求的：corePoolSize不能小于0；maximumPoolSize需要大于0，且需要大于等于corePoolSize；keepAliveTime大于0；workQueue、threadFactory都不能为null。

       在创建完后就需要执行Runnable了，看以下execute()方法：

       在execute()内部主要执行的逻辑如下：

       分析点1：如果当前线程数未超过核心线程数，则将runnable作为参数执行addWorker()，true表示核心线程，false表示非核心线程；

       分析点2：核心线程满了，如果线程池处于运行状态则往workQueue队列中添加任务，接下来判断是否需要拒绝或者执行addWorker()；

       分析点3：以上都不满足时 [corePoolSize=0且没有运行的线程，或workQueue已经满了] ，执行addWorker()添加runnable，失败则执行拒绝策略；

        总结一下：线程池对线程创建的管理，流程图如下：

       在执行addWorker时，主要做了以下两件事：

       分析点1：将runnable作为参数创建Worker对象w，然后获取w内部的变量thread；

       分析点2：调用start()来启动thread；

       在addWorker()内部会将runnable作为参数传给Worker，然后从Worker内部读取变量thread，看一下Worker类的实现：

       Worker实现了Runnable接口，在Worker内部，进行了赋值及创建操作，先将execute()时传入的runnable赋值给内部变量firstTask，然后通过ThreadFactory.newThread(this)创建Thread，上面讲到在addWorker内部执行t.start()后，会执行到Worker内部的run()方法，接着会执行runWorker(this)，一起看一下：

       前面可以看到，runWorker是执行在子线程内部，主要执行了三件事：

       分析1：获取当前线程，当执行shutdown()时需要将线程interrupt()，接下来从Worker内部取到firstTask，即execute传入的runnable，接下来会执行；

       分析2：while循环，task不空直接执行；否则执行getTask()去获取，不为空直接执行；

       分析3：对有效的task执行run()，由于是在子线程中执行，因此直接run()即可，不需要start()；

       前面看到，在while内部有执行getTask()，一起看一下：

       getTask()是从workQueue内部获取接下来需要执行的runnable，内部主要做了两件事：

       分析1：先获取到当前正在执行工作的线程数量wc，通过判断allowCoreThreadTimeOut[在创建ThreadPoolExecutor时可以进行设置]及wc corePoolSize来确定timed值；

       分析2：通过timed值来决定执行poll()或者take()，如果WorkQueue中有未执行的线程时，两者作用是相同的，立刻返回线程；如果WorkQueue中没有线程时，poll()有超时返回，take()会一直阻塞；如果allowCoreThreadTimeOut为true，则核心线程在超时时间没有使用的话，是需要退出的；wc corePoolSize时，非核心线程在超时时间没有使用的话，是需要退出的；

       allowCoreThreadTimeOut是可以通过以下方式进行设置的：

       如果没有进行设置，那么corePoolSize数量的核心线程会一直存在。

        总结一下：ThreadPoolExecutor内部的核心线程如何确保一直存在，不退出？

       上面分析已经回答了这个问题，每个线程在执行时会执行runWorker()，而在runWorker()内部有while()循环会判断getTask()，在getTask()内部会对当前执行的线程数量及allowCoreThreadTimeOut进行实时判断，如果工作数量大于corePoolSize且workQueue中没有未执行的线程时，会执行poll()超时退出；如果工作数量不大于corePoolSize且workQueue中没有未执行的线程时，会执行take()进行阻塞，确保有corePoolSize数量的线程阻塞在runWorker()内部的while()循环不退出。

       如果需要关闭线程池，需要如何操作呢，看一下shutdown()方法：

       以上可以看到，关闭线程池的原理：a. 遍历线程池中的所有工作线程；b. 逐个调用线程的interrupt()中断线程（注：无法响应中断的任务可能永远无法终止）

       也可调用shutdownNow()来关闭线程池，二者区别：

       shutdown()：设置线程池的状态为SHUTDOWN，然后中断所有没有正在执行任务的线程；

       shutdownNow()：设置线程池的状态为STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表；

       使用建议：一般调用shutdown()关闭线程池；若任务不一定要执行完，则调用shutdownNow()；

        总结一下：ThreadPoolExecutor在执行execute()及shutdown()时的调用关系，流程图如下：

       线程池可以通过Executors来进行不同类型的创建，具体分为四种不同的类型，如下：

       可缓存线程池：不固定线程数量，且支持最大为Integer.MAX_VALUE的线程数量：

       1、线程数无限制

       2、有空闲线程则复用空闲线程，若无空闲线程则新建线程

       3、一定程度上减少频繁创建/销毁线程，减少系统开销

       固定线程数量的线程池：定长线程池

       1、可控制线程最大并发数(同时执行的线程数)

       2、超出的线程会在队列中等待。

       单线程化的线程池：可以理解为线程数量为1的FixedThreadPool

       1、有且仅有一个工作线程执行任务

       2、所有任务按照指定顺序执行，即遵循队列的入队出队规则

       定时以指定周期循环执行任务

       一般来说，等待队列 BlockingQueue 有: ArrayBlockingQueue 、 LinkedBlockingQueue 与 SynchronousQueue 。

       假设向线程池提交任务时，核心线程都被占用的情况下:

        ArrayBlockingQueue ：基于数组的阻塞队列，初始化需要指定固定大小。

       当使用此队列时，向线程池提交任务，会首先加入到等待队列中，当等待队列满了之后，再次提交任务，尝试加入队列就会失败，这时就会检查如果当前线程池中的线程数未达到最大线程，则会新建线程执行新提交的任务。所以最终可能出现后提交的任务先执行，而先提交的任务一直在等待。

        LinkedBlockingQueue ：基于链表实现的阻塞队列，初始化可以指定大小，也可以不指定。

       当指定大小后，行为就和 ArrayBlockingQueue一致。而如果未指定大小，则会使用默认的 Integer.MAX_VALUE 作为队列大小。这时候就会出现线程池的最大线程数参数无用，因为无论如何，向线程池提交任务加入等待队列都会成功。最终意味着所有任务都是在核心线程执行。如果核心线程一直被占，那就一直等待。

        SynchronousQueue ：无容量的队列。

       使用此队列意味着希望获得最大并发量。因为无论如何，向线程池提交任务，往队列提交任务都会失败。而失败后如果没有空闲的非核心线程，就会检查如果当前线程池中的线程数未达到最大线程，则会新建线程执行新提交的任务。完全没有任何等待，唯一制约它的就是最大线程数的个数。因此一般配合Integer.MAX_VALUE就实现了真正的无等待。

       但是需要注意的是， 进程的内存是存在限制的，而每一个线程都需要分配一定的内存。所以线程并不能无限个。