这是一篇 写的非常用心的 博文,这里是原文地址
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现象（程序卡死）。
而造成这种现象的主要原因有：
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机制不太了解，
上面只是单纯的一个网络请求，那么现在需求来了，这个界面不止一个网络请求，可能存在大量的网络请求，这时候就会有问题产生：
（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>
