深入理解在Android中线程池的使用
来源:互联网 发布:java中的initcause方法 编辑:程序博客网 时间:2024/05/23 01:23
本文出自博客Vander丶CSDN博客,如需转载请标明出处,尊重原创谢谢
博客地址:http://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)这个方法不会等待所有任务都执行完在提交,如果想先让所有任务先完成请使用awaitTermination()方法.
awaitTermination()
阻塞至直到当前任务完全结束之后,才会关闭请求,或者超时的发生,也或者线程被中断 看哪个发生的快.
参数: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/513771743.理解java线程的中断(interrupt)http://blog.csdn.net/canot/article/details/51087772
- 深入理解在Android中线程池的使用
- 深入理解Android线程池
- Android 中使用线程锁的理解
- android中对线程池的理解与使用
- android中对线程池的理解与使用
- android中对线程池的理解与使用
- PRODUCT_COPY_FILES的深入理解,为何不能在Android.mk使用
- Android 中线程池的理解
- Android线程池的使用与理解
- 理解Java与Android中线程与线程池的原理和使用
- 线程池深入理解
- 深入理解线程池
- 深入理解线程池
- 深入理解Android异步线程
- Android中pendingIntent的深入理解
- Android中pendingIntent的深入理解
- Android中pendingIntent的深入理解
- Android中pendingIntent的深入理解
- 203. Remove Linked List Elements
- L3-004. 肿瘤诊断
- c#中的窗口关闭事件如何活
- FishC笔记—20 讲 函数:内嵌函数和闭包
- 接口关系下的多态
- 深入理解在Android中线程池的使用
- TensorFlow MNIST 测试
- 程序设计方法学———— 三天打鱼两天晒网(日期判定)
- TI-RTOS 内核概述,开发蓝牙功能必须要熟悉的实时操作系统
- go语言选择语句 switch case
- Stereo Matching文献笔记之(八):《On Building an Accurate Stereo Matching System on Graphics Hardware》读后感~
- a标签的伪类选择器
- 从前端获取ID时,出现前缀怎么办
- 成员内部类