[转]深入理解在Android中线程池的使用

这是一篇 写的非常用心的 博文,这里是原文地址
https://blog.csdn.net/l540675759/article/details/62230562

前言

(1)本文共花费2周零3天的凌晨时光,这段时间收获很多. (2)从整理文章,作者从线程-->阻塞队列-->二进制-->线程池的内部机制,一路走来,本来是想写一篇为AsyncTask做铺垫的文章,没想到越写越多. (3)文章中如果错误,请大家及时指正,作者会及时更新. (4)希望大家能够从文章中.多多收获,迄今为止,博主最好的一篇文章,也是花了大力气最用心的一篇文章. 

线程

在了解线程池之前，先给大家介绍下线程的概念：

先看一个烧水的例子，图中看电视是主线，用户想在看电视的过程中去完成烧水这个操作，并且不耽误看电视，看了这张图，在去了解接下来的概念会更好的理解主线程与子线程的概念。

线程是什么？

从底层角度来说：
一个线程就是在进程中的一个单一的顺序控制流.

而单个进程可以拥有多个并发执行的任务，每个任务都好像有自己的CPU一样，而其底层的机制就是切分CPU的时间，也就是CPU将轮流给每个任务分配其占用时间。

每个任务都觉得自己在一直占用CPU，而事实上是将CPU时间划分成片段分配给所有的任务。

在多个CPU的环境下，多线程的运作，可以极大的提供程序的运行速度，这就是线程存在的意义。

---

那么在Android中，线程的作用是？

首先，先了解下Android下进程和线程的概念：
这里引用Gityuan作者在知乎上的回答，关于线程和进程的概念

进程：每个app运行时前首先创建一个进程，该进程是由Zygote fork出来的，用于承载App上运行的各种Activity/Service等组件。
进程对于上层应用来说是完全透明的，这也是google有意为之，让App程序都是运行在Android Runtime。大多数情况一个App就运行在一个进程中，除非在AndroidManifest.xml中配置Android:process属性，或通过native代码fork进程。

线程：线程对应用来说非常常见，比如每次new Thread().start都会创建一个新的线程。该线程与App所在进程之间资源共享，从Linux角度来说进程与线程除了是否共享资源外，并没有本质的区别，都是一个task_struct结构体，在CPU看来进程或线程无非就是一段可执行的代码，CPU采用CFS调度算法，保证每个task都尽可能公平的享有CPU时间片。

---

上面可能还是比较专业，这里简要总结下线程在Android的作用：

（1）在Android中线程分主线程和子线程，主线程也被称为UI线程，用来处理各种和界面相关的事情，
例 ：界面的加载，Activity的生命周期这些都在主线程的范畴之内。

（2）由于主线程比较特殊，因为本身主线程在处理界面上，用了大部分的消耗，所以主线程不能再处理过于耗时的操作（IO操作，网络请求，大量的数据操作），否则就会造成ANR现象（程序卡死）。

什么是ANR？，这里百度上有比较全的介绍

而造成这种现象的主要原因有：

Activity响应时间超过5s

Broadcast在处理时间超过10s

Service处理时间超过20s

这大部分的原因是主线程进行过于耗时的操作，因为Activity，Broadcast，Serivce本身都是通过主线程进行承载的。

（3）此时子线程就横空出世解决了这类问题，Android建议耗时操作必须放在子线程中运行。

（4）而在Android中可以解决耗时问题的角色除了Thread之外还有AsyncTask，HandlerThread，IntentService，都可以实现此类功能，而他们的本质还是传统的线程。

---

为什么会有线程池？

从字面上来看，线程池是存放，和管理线程的池子。那么为什么会有线程池呢？

先看一个例子，这里我用Handler和Thread来模拟网络请求的操作：

 private Handler mHandler = new Handler(new Handler.Callback() { @Override public boolean handleMessage(Message msg) { if (msg.what == TASK_ACTION) { Log.d("收到消息", "更新UI"); } return false; } }); 

 new Thread(new Runnable() { @Override public void run() { try { //模拟网络请求 Thread.sleep(1000); mHandler.sendEmptyMessage(TASK_ACTION); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); 

上面过程，只是用一个Thread来模拟正常的网络请求，然后通过Handler来回调给UI线程，通知UI线程来刷新，如果对Handler机制不太了解，

一篇不错的Handler介绍的文章

上面只是单纯的一个网络请求，那么现在需求来了，这个界面不止一个网络请求，可能存在大量的网络请求，这时候就会有问题产生：

（1）当大量的网络请求产生，就会大量的创建和销毁线程，因此可能会造成过大的性能开销。

（2）当大量的线程一起运作的时候，可能会造成资源紧张，上面也介绍过线程底层的机制就是切分CPU的时间，而大量的线程同时存在时可能造成互相抢占资源的现象发生，从而导致阻塞的现象。

基于以上背景，线程池适当的出现可以很好的解决上述的问题，而上述模拟网络请求也只是一个简单的例子，而现实情况下，会有好多种情况和上述相似，比如在数据库操作大数据，多线程下载，在使用Thread的同时都会出现上述情况。

---

什么是线程池？

Android中的线程池的概念来源于Java中的Executor，Executor是一个接口，真正的线程池的实现为ThreadPoolExecutor，ThreadPoolExecutor提供了一系列参数来配置线程池，通过不同的参数可以创建不同的线程池。

线程池的优点：

线程池的出现，恰恰就是解决上面类似问题的痛点，而线程池的优点有：

（1）复用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。

（2）能够有效的控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致的阻塞现象。

（3）能够对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能。

---

线程池的构造方法

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

上面代码是创建一个基本的线程池需要的参数，让我们通过图来简要的描述下：

由上图可以简要的描述出创建一个基本的线程池需要的参数，以及各个参数的含义，下面将详细说明各个参数的具体含义。

---

CorePoolSize
线程的核心线程数。

默认情况下，核心线程数会在线程中一直存活，即使它们处于闲置状态。

如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，那么核心线程就会存在超时策略，这个时间间隔有keepAliveTime所决定，当等待时间超过keepAliveTime所指定的时长后，核心线程就会被停止。

---

maximumPoolSize
线程池所能容纳的最大线程数。

当活动线程数达到这个数值后，后续的新任务将会被阻塞。

---

keepAliveTime
非核心线程闲置时的超时时长，超过这个时长，非核心线程就会被回收，当ThreadPoolExector的allowCoreThreadTimeOut属性设置为True时，keepAliveTime同样会作用于核心线程。

---

unit
用于指定keepAliveTime参数的时间单位，这是一个枚举，常用的有TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS(秒)以及TimeUnit.MINUTES(分钟)等。

TimeUnit.NANOSECONDS 纳秒 TimeUnit.MICROSECONDS 微秒 TimeUnit.MILLISECONDS 毫秒 TimeUnit.SECONDS 秒 TimeUnit.MINUTES 分钟 TimeUnit.HOURS 小时 TimeUnit.DAYS 天 

---

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

这个任务队列是BlockQueue类型，属于阻塞队列，就是当队列为空的时候，此时取出任务的操作会被阻塞，等待任务加入队列中不为空的时候，才能进行取出操作，而在满队列的时候，添加操作同样被阻塞。

如果有想了解的可以参考下这篇文章：
Java多线程-工具篇-BlockingQueue

---

threadFactory
线程工厂，为线程池提供创建新线程的功能。ThreadFactory是一个接口，它只有一个方法，newThread（Runnable r），用来创建线程。

 ThreadFactory factory =new ThreadFactory() { //线程安全的Integer操作类 private final AtomicInteger mCount =new AtomicInteger(1); @Override public Thread newThread(Runnable r) { return new Thread(r, "new Thread #" + mCount.getAndIncrement()); } }; 

---

线程池的源码解析

打开源码,先把线程池源码中除了构造参数,其他的一些基本属性,先给分析一下.

线程池的生命周期

 //这里在线程池统计数值,用AtomicInteger,它是一种线程安全的加减操作类 //初始生命周期是RUNNING,工作线程的初始数量是0 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); //进行移位操作需要的常量 Integer.SIZE =32 bit位 private static final int COUNT_BITS = Integer.SIZE - 3; //进行位运算需要的常量 private static final int CAPACITY = (1 << COUNT_BITS) - 1; //进行高位运算 private static final int RUNNING = -1 << COUNT_BITS; private static final int SHUTDOWN = 0 << COUNT_BITS; private static final int STOP = 1 << COUNT_BITS; private static final int TIDYING = 2 << COUNT_BITS; private static final int TERMINATED = 3 << COUNT_BITS; 

将上述高位运算就是将 0 和1以及其他的数值在二进制下,向左移位29位,缺位用0补齐,实际结果就变成:

# 接受新任务,并且处理队列任务的状态 RUNNING = 111 000...000 (29个0) # 不接受新任务,但是会处理队列任务的状态 SHUTDOWN = 000 000...000 (29个0不包括前三位) # 不接受新任务,并且也不会处理队列任务的状态 STOP = 001 000...000 (29个0) # 所有线程池内线程都将被终止,并且将workCount清零,在这里状态下将会运行terminated()方法(终止线程池的方法) TIDYING = 010 000...000 (29个0) # terminated()方法以及结束的状态 TERMINATED = 011 000...000 (29个0) 

 /** * 获取到当前线程池的生命周期的状态 */ private static int runStateOf(int c) { return c & ~CAPACITY; } /** * 获取当前线程池的工作线程状态 */ private static int workerCountOf(int c) { return c & CAPACITY; } /** * 通过或运算拼接线程的生命周期状态和工作线程的个数 */ private static int ctlOf(int rs, int wc) { return rs | wc; } 

上面的三个函数是获取当前线程池状态的方法,这里简单介绍下:
(1) ctlOf()有两个参数,一个是生命周期状态,一个是当前线程池工作线程.
生命周期的状态格式:
XXX 0000…0000(29个0)
ctlOf()返回的值就是将工作线程数量转化成2进制拼接在生命周期的二进制后半段上.

(2) runStateOf()和workerCountOf()方法都是让生命周期的状态值与CAPACITY和CAPACITY的反码进行与运算,简明的说,就是获得二进制数的高位(前三位)和低位(后29位).

如果大家比较了解位运算可以发现:

CAPACITY ------> 000 1111...1111 (29个1) ~CAPACITY ------> 111 0000...0000 (29个0) 

所以在进行与运算的同时,可以分别取出前3位和后29位,来分别代表线程池的生命周期和工作线程数.

---

其他属性

 /** * 无法执行任务的通知类 * 在Android中不太常用 */ private static final RejectedExecutionHandler defaultHandler = new AbortPolicy(); 

当线程池无法执行任务,这可能由于任务队列已满或者是无法成功执行任务.这个时候ThreadPoolExecution就会调用handler的rejectedExecution方法来通知调用者.

 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString()); } 

默认情况下,rejectedExecution会抛出个RejectedExecutionException异常,来说明为什么当前无法执行任务.

ThreadPoolExecution为RejectedExecutionException提供了几个可选值:

----------------------------CallerRunsPolicy------------------- //拒绝任务时,判断线程池的状态是否为SHUTDOWN,如果是任务将会被丢弃,如果不是的话任务会被继续执行. public void rejectedExecution(Runnable r, ThreadPoolExecutor e){ if (!e.isShutdown()) { r.run(); } } -------------------------AbortPolicy(默认值)--------------------- //拒绝任务时,直接抛出异常和原因 public void rejectedExecution(Runnable r, ThreadPoolExecutor e){ throw new RejectedExecutionException( "Task " + r.toString() + " rejected from " +e.toString()); } -------------------------DiscardPolicy-------------------------- //就是单纯的拒绝任务而已,什么也不会发生,任务也将丢失public void rejectedExecution(Runnable r, ThreadPoolExecutor e){ //什么没发生 } ----------------------DiscardOldestPolicy----------------------- //拒绝任务时,判断线程池的状态是否为SHUTDOWN,如果是任务将会被丢弃,如果不是的话,将当前请求队列中等待时间最长的任务弹出,将其加入队列中. public void rejectedExecution(Runnable r, ThreadPoolExecutor e){ if (!e.isShutdown()) { e.getQueue().poll(); e.execute(r); } } 

---

比较重要的方法

线程池有两个执行的方法,分别是submit()和execute(),这两个方法本质的含义是一样的.

从图上可以看出的,submit()其实还是需要调用execute()去执行任务,而submit()和execute()本质上的不同是submit()将包装好的任务进行了返回.

submit()

 public <T> Future<T> submit(Callable<T> task) { if (task == null) throw new NullPointerException(); RunnableFuture<T> ftask = newTaskFor(task); //还是通过调用execute execute(ftask); //最后会将包装好的Runable返回 return ftask; } //将Callable<T> 包装进FutureTask中 protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { return new FutureTask<T>(callable); } //可以看出FutureTask也是实现Runnable接口,因为RunableFuture本身就继承了Runnabel接口 public class FutureTask<V> implements RunnableFuture<V> { ....... } public interface RunnableFuture<V> extends Runnable, Future<V> { /** * Sets this Future to the result of its computation * unless it has been cancelled. */ void run(); } 

---

execute()

 public void execute(Runnable command) { if (command == null) throw new NullPointerException(); //获得当前线程的生命周期对应的二进制状态码 int c = ctl.get(); //判断当前线程数量是否小于核心线程数量,如果小于就直接创建核心线程执行任务,创建成功直接跳出,失败则接着往下走. if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); } //判断线程池是否为RUNNING状态,并且将任务添加至队列中. if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); //审核下线程池的状态,如果不是RUNNING状态,直接移除队列中 if (! isRunning(recheck) && remove(command)) reject(command); //如果当前线程数量为0,则单独创建线程,而不指定任务. else if (workerCountOf(recheck) == 0) addWorker(null, false); } //如果不满足上述条件,尝试创建一个非核心线程来执行任务,如果创建失败,调用reject()方法. else if (!addWorker(command, false)) reject(command); } 

下图是一张execute()方法的基本流程:

从execute()方法中,能看出addWorker()方法,是创建线程(核心线程,非核心线程)的主要方法,而reject()就是线程创建失败的一个回调.

---

reject()

那我们来看一下reject()方法,这里就是通过上述的Handler将通知发出去.然后针对不同的类型的RejectedExecutionHandler,进行不同的处理,这里我们上文有介绍.

 final void reject(Runnable command) { handler.rejectedExecution(command, this); } 

---

下面我们着重看下创建线程的方法:
addWorker()

参数 :

Runnable firstTask:

为传递进来需要执行的任务,也可以设置为null(在SHUTDOWN情况下,单纯的创建线程来执行任务).

boolean core:

需要创建的线程是否需要是核心线程.

 private boolean addWorker(Runnable firstTask, boolean core) { //类似goto,是Java的标识符,在这里出现是为了防止在多线程的情况下,compareAndIncrementWorkerCount(),计算线程池状态出现问题,而设立重试的关键字. retry: for (;;) { int c = ctl.get(); int rs = runStateOf(c); //看似判断条件很麻烦 //分拆后主要两点 //线程已经处于STOP或者即将STOP的状态 //或者 处于SHUTDOWN状态,并且传递的任务为null,此时队列不为空还需要增加线程,除了这种情况,其他情况都不需要增加线程 //以上的情况就不需要 if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false; //判断当前工作线程数量是否超过最大值 //或者当前工作线程数量超过 核心线程数或者最大线程数,这个值根据第二个布尔变量决定 for (;;) { int wc = workerCountOf(c); if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false; //这段函数是判断 线程池状态的统计更新成没成功 //如果成功直接跳出这个循环,继续执行 if (compareAndIncrementWorkerCount(c)) break retry; c = ctl.get(); // Re-read ctl if (runStateOf(c) != rs) continue retry; //如果不成功则跳到外层循环入口,重新执行. retry inner loop } } //下面是创建线程的过程,并且在创建线程的过程中加锁 //Worker就是线程的一个包装类. //这里分别对线程的创建成功和失败分别做出了处理. boolean workerStarted = false; boolean workerAdded = false; Worker w = null; try { w = new Worker(firstTask); final Thread t = w.thread; if (t != null) { //创建线程的过程中,加锁防止并发现象发生. final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { int rs = runStateOf(ctl.get()); //从这里可以看出线程池创建线程,只会在两种情况下创建: //1.线程池在RUNNING状态(rs<SHUTDOWN) //2.线程池处于SHUTDOWN状态,并且任务为null,但是此时任务队列不为空,需要继续增加线程来加快处理进度. if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { //在这里就是先检查下Thread状态,防止意外发生. if (t.isAlive()) throw new IllegalThreadStateException(); workers.add(w); //这里做了一个容量的判断 int s = workers.size(); if (s > largestPoolSize) largestPoolSize = s; workerAdded = true; } } finally { mainLock.unlock(); } //如果线程已经增加成功,然后设置标志 if (workerAdded) { t.start(); workerStarted = true; } } } finally { //最后如果线程没有开始,就分发到添加线程失败,通过标志位来判断线程是否被添加成功. if (! workerStarted) addWorkerFailed(w); } //如果添加成功就返回true,否则添加失败就返回false. return workerStarted; } 

addWorker()方法的注意事项:

(1)增加一个线程,并且会为其绑定core或者maximum的线程标志. (2)如果成功添加线程来执行当前任务,那么当前线程池的状态会被刷新. (3)在添加第一个任务firstTask的这种情况下,新的工作线程会被创建后立即执行任务. (4)该方法会在线程池STOP状态或者符合资格去关闭会返回false. (5)线程工厂创建线程失败的时候,同样也会返回false. (6)在由于线程创建失败,线程工厂返回的线程为null,或者发生异常(通常由于在线程执行的过程中发生了OOM),线程池会进行回滚操作. 

---

addWorker()方法执行的几个阶段

第一阶段 :

状态检查

在创建线程时,首先检查线程池状态,防止线程处于STOP,TIDYING,TERMINATED状态,如果处于上述状态直接返回false. 然后对于在SHUTDOWN状态下,只有当前任务队列不为空,并且传递的任务参数为null.这种状态下可以创建线程来执行剩余任务,除此之外全部直接返回false. 

 if (rs >= SHUTDOWN &&! (rs == SHUTDOWN && firstTask == null &&! workQueue.isEmpty())) return false; 

---

第二阶段 :

判断当前线程池的能否创建线程以及可以创建之后的数量添加校验

(1)当前线程的数量是否超过线程池的最大容量,以及根据core参数来判断是否超过设置的核心线程数,和最大线程数. (2)通过第一步之后就可以创建线程,这里需要用到compareAndIncrementWorkerCount()通过原子操作来更新线程池的线程数量变化,如果变化数量失败,这里有一个重试机制,这个retry关键字就是来完成这个操作. (3)这里注明下CAPACITY这个常量就是线程池的线程数量的极限 CAPACITY = 1>>29 -1 =2^29-1 

 for (;;) { int wc = workerCountOf(c); if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false; if (compareAndIncrementWorkerCount(c)) break retry; c = ctl.get(); // Re-read ctl if (runStateOf(c) != rs) continue retry; } 

---

第三阶段 :

创建线程

通过上述阶段,那么就可以创建线程了,这里设置了两个初始的标志位,来判断被创建线程的状态. boolean workerStarted = false; boolean workerAdded = false; 如果最终线程创建并添加成功,则返回true,如果线程最终没有被运行,则调用addWorkerFailed()方法. 由于逻辑并不复杂,这里就不贴代码了. 

---

其他相关方法

addWorkedFailed()

在addWorker()方法中,如果线程创建之后,没有最终运行(workerStarted=false)这时候会调用addWorkedFailed()方法.

 /** * 回滚工作线程的创建操作: * 1.如果线程的包装类Worker存在,就将其remove掉. * 2.remove掉添加线程失败的Worker,需要刷新当前工作线程的数量 * 3.尝试终止操作,并且终止这个线程的操作. */ private void addWorkerFailed(Worker w) { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { if (w != null) workers.remove(w); decrementWorkerCount(); //尝试停止操作. tryTerminate(); } finally { mainLock.unlock(); } } 

---

tryTerminate()

而在addWorkedFailed()方法中,我们发现除了回滚操作,它还调用了tryTerminate()方法,尝试着去停止线程池.因为线程池创建线程失败一般由于异常引起(或OOM),所以这时候需要让线程池进行停止操作.

注意事项:

如果发生以下两种情况,使用该方法将会将线程池转换为终止状态(TERMINATED): 1.SHUTDOWN状态下,队列为空的情况下. 2.STOP状态下. 如果符合上述条件,可以转换终止状态时,这时会中断当前线程池内空闲的线程,以确保终止的信号的传递. 

 final void tryTerminate() { for (;;) { int c = ctl.get(); //检测当前是RUNNING状态,或者已经停止(TERMINATED)的状态,或者SHUTDOWN状态下,队列不为空. if (isRunning(c) || runStateAtLeast(c, TIDYING) || (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty())) return; //如果工作线程的数量不为空,这时候需要处理空闲线程,这里只中断一个其中一个线程,这里博主认为是将线程池的状态由SHUTDOWN向STOP状态过渡的信号. if (workerCountOf(c) != 0) { interruptIdleWorkers(ONLY_ONE); return; } final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { //设置当前的线程池状态为TIDYING,如果设置失败,还会进入循环直到设置成功. if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) { try { //停止方法的空实现 terminated(); } finally { //最终线程池会设置为停止状态 ctl.set(ctlOf(TERMINATED, 0)); //设置可重新入锁的标志,将被锁隔离的在外等待的所有线程唤醒. termination.signalAll(); } return; } } finally { mainLock.unlock(); } } } 

---

interruptIdleWorkers()

而在tryTerminate()方法中,这里中断线程的操作就是由interruptIdleWorkers()方法进行的.

这个方法作用很明确,就是设置线程中断操作的方法,唯一注意的地方就是参数onlyOne:

如果为true,只中断工作线程中的一个线程. 如果为false,中断所有的工作线程. 

 private void interruptIdleWorkers(boolean onlyOne) { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { for (Worker w : workers) { Thread t = w.thread; //检查线程的状态 if (!t.isInterrupted() && w.tryLock()) { try { t.interrupt(); } catch (SecurityException ignore) { } finally { w.unlock(); } } //如果onlyOne参数为True,则只执行一次就跳出. if (onlyOne) break; } } finally { mainLock.unlock(); } } 

---

shutdown()
而中断所有空闲的线程方法则是shutdown()方法,它的核心方法还是调用interruptIdleWorkers()方法.

 public void shutdown() { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { //校验线程的状态 checkShutdownAccess(); //设置线程池状态为SHUTDOWN advanceRunState(SHUTDOWN); //中断所有空闲进程.调用的interruptIdleWorkers(false); interruptIdleWorkers(); //需要自己实现,在中断所有线程可定制的操作 onShutdown(); } finally { mainLock.unlock(); } tryTerminate(); } 

注意事项:
(1)在shutdown()执行时可以让现有的任务被执行,但是新的任务不在会被处理.

(2)如果已经是SHUTDOWN状态,那么继续调用不会产生任何效果.

(3)shutdown()方法只会中断空闲的线程,但是不会影响到已经存入队列的任务,如果需要停止线程池的运行,可以使用awaitTermination()方法.

---

awaitTermination()

阻塞方法,强行等待当前队列中的任务全部为TERMINATED状态,可以设置超时时间.

参数:d
timeout —- 设置超时时间
unit —- 设置超时时间的单位

 public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { //设置时间 long nanos = unit.toNanos(timeout); final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { //这是死循环,当线程池的状态为TERMINATED时,跳出循环返回true,也就是所有任务都完成.否则超时或者线程中断则返回false. while (!runStateAtLeast(ctl.get(), TERMINATED)) { if (nanos <= 0L) return false; nanos = termination.awaitNanos(nanos); } return true; } finally { mainLock.unlock(); } } 

---

线程池的分类

Android中最常见的四类具有不同功能特性的线程池:

1.FixedThreadPool

//特点: //核心线程数和最大线程数相同. //无超时时间 public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>() ); 

这是一种数量固定的线程池,当线程处于空闲的时候,并不会被回收,除非线程池被关闭.

当所有的线程都处于活动状态时,新任务都会处于等待状态,直到有线程空闲出来.

由于FixedThreadPool中只有核心线程并且这些核心线程不会被回收,这意味着它能够更加快速地响应外界的请求.

通过构造方法可以看出,FixedThreadPool只有核心线程,并且超时时间为0(即无超时时间),所以不会被回收.

---

2.CacheThreadPool

//无核心线程,并且最大线程数为int的最大值. //超时时间为60s //队列为SynchronousQueue同步阻塞队列,队列中没有任何容量.只有在有需求的情况下,队列中才可以试着添加任务. public static ExecutorService newCacheThreadPool(){ return new ThreadPoolExecutor( 0,Integer.MAX_VALUE, 60L,TimeUnit.SECONDS, new SynchronousQueue<Runnable>() ); } 

它是一种线程数量不定的线程池,它只有非核心线程,并且其最大线程数为Integer.MAX_VALUE(也就相当于线程池的线程数量可以无限大).

当线程池中所有线程都处于活动的状态时,线程池会创建新的线程来处理新任务,否则就会复用空闲线程来处理.

值得注意的是,这个线程池中储存任务的队列是SynchronousQueue队列,这个队列可以理解为无法储存的队列,只有在可以取出的情况下,才会向其内添加任务.

从整个CacheThreadPool的特性来看:

(1)比较适合执行大量的耗时较少的任务.

(2)当整个线程都处于闲置状态时,线程池中的线程都会超时而被停止,这时候的CacheThreadPool几乎不占任何系统资源的.

---

3.ScheduledThreadPool

 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSzie) { return new ScheduledThreadPoolExecutor(corePoolSzie); } //核心线程数是固定的,非核心线程无限大,并且非核心线程数有10s的空闲存活时间 public ScheduledThreadPoolExecutor(int corePoolSize) { super(corePoolSize, Integer.MAX_VALUE, DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS, new DelayedWorkQueue()); } 

它的核心线程数量是固定的,而非核心线程数是没有限制的,并且当非核心线程闲置时会被立即回收.

ScheduThreadPool这类线程池主要用于执行定时任务和具有固定周期的重复任务.

而DelayedWorkQueue这个队列就是包装过的DelayedQueue,这个类的特点是在存入时会有一个Delay对象一起存入,代表需要过多少时间才能取出,相当于一个延时队列.

4.SingleThreadExecutor

 public static ExecutorService newSingleThreadExecutor() { return Executors.newSingleThreadExecutor(); } //特点: //线程中只有一个核心线程 //并且无超时时间 public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); } 

这类线程池内部只有一个核心线程,它确保所有的任务都在同一个线程中按顺序执行.

SingleThreadExecutor的意义在于统一外界所有任务到一个线程,这使得这些任务之间不需要处理线程同步的问题.

---

参考文档:

1.安卓开发艺术探索 2.ThreadPoolExecutor解析-主要源码研究 http://blog.csdn.net/wenhuayuzhihui/article/details/51377174 3.理解java线程的中断(interrupt) http://blog.csdn.net/canot/article/details/51087772 

</article>