Java多线程之线程池深入讲解
1 线程池介绍
1.1 线程池概念
Sun
在Java5
中,对Java
线程的类库做了大量的扩展,其中线程池就是Java5
的新特征之一,除了线程池之外,还有很多多线程相关的内容,为多线程的编程带来了极大便利。为了编写高效稳定可靠的多线程程序,线程部分的新增内容显得尤为重要。
有关Java5
线程新特征的内容全部在java.util.concurrent
下面,里面包含数目众多的接口和类,熟悉这部分API特征是一项艰难的学习过程
线程池的基本思想还是一种对象池的思想,开辟一块内存空间,里面存放了众多(未死亡)的线程,池中线程执行调度由池管理器来处理。当有线程任务时,从池中取一个,执行完成后线程对象归池,这样可以避免反复创建线程对象所带来的性能开销,节省了系统的资源。
1.2 线程池好处
合理利用线程池能够带来三个好处
第一:降低资源消耗
。通过重复利用已创建的线程降低线程创建和销毁造成的消耗
第二:提高响应速度
。当任务到达时,任务可以不需要等到线程创建就能立即执行
第三:提高线程的可管理性
。线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。但是要做到合理的利用线程池,必须对其原理了如指掌。
2 线程池的使用
2.1 线程池的创建
2.1.1 通过ThreadPoolExecutor创建
我们可以通过ThreadPoolExecutor
来创建一个线程池
new ThreadPoolExecutor(corePoolSize, maximumPoolSize,keepAliveTime, timeUnit,
runnableTaskQueue, threadFactory,handler);
创建一个线程池需要输入几个参数:
corePoolSize
(线程池的基本大小):当提交一个任务到线程池时,线程池会创建一个线程来执行任务,即使其他空闲的基本线程能够执行新任务也会创建线程,等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads
方法,线程池会提前创建并启动所有基本线程。runnableTaskQueue
(任务队列):用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列:ArrayBlockingQueue
:是一个基于数组结构的有界阻塞队列
,此队列按FIFO
(先进先出)原则对元素进行排序,必须指定队列大小。LinkedBlockingQueue
:一个基于链表结构的有界/(无界:未指定容量则Integer.MAX_VALUE)阻塞队列
,此队列按FIFO
(先进先出) 排序元素,吞吐量通常要高于ArrayBlockingQueue
。静态工厂方法Executors.newFixedThreadPool()
和newSingleThreadExecutor
使用了这个队列,注意
:如果不指定队列大小,就默认为Integer.MAX_VALUE
。SynchronousQueue
:一个无容量的阻塞队列。每个插入操作必须等到另一个线程调用移除操作,否则插入操作一直处于阻塞状态,吞吐量通常要高于LinkedBlockingQueue
,静态工厂方法Executors.newCachedThreadPool
使用了这个队列。PriorityBlockingQueue
:一个具有优先级得无限阻塞队列。存放在PriorityBlockingQueue
中的元素必须实现Comparable
接口,这样才能通过实现compareTo()
方法进行排序。优先级最高的元素将始终排在队列的头部;PriorityBlockingQueue
不会保证优先级一样的元素的排序,也不保证当前队列中除了优先级最高的元素以外的元素,随时处于正确排序的位置。DelayedWorkQueue
:一个使用优先级队列实现的无界阻塞队列,静态工厂方法Executors.newScheduledThreadPool
使用
基于二叉堆实现,同时具备:无界队列、阻塞队列、优先队列的特征。DelayQueue
延迟队列中存放的对象,必须是实现Delayed
接口的类对象。通过执行时延从队列中提取任务,时间没到任务取不出来。LinkedBlockingDeque
: 双端队列,有界/(无界:未指定容量则Integer.MAX_VALUE)阻塞队列
,基于链表实现,既可以从尾部插入/取出元素,还可以从头部插入元素/取出元素。LinkedTransferQueue
: 由链表结构组成的无界阻塞队列。这个队列比较特别的时,采用一种预占模式,意思就是消费者线程取元素时,如果队列不为空,则直接取走数据,若队列为空,那就生成一个节点(节点元素为null
)入队,然后消费者线程被等待在这个节点上,后面生产者线程入队时发现有一个元素为null
的节点,生产者线程就不入队了,直接就将元素填充到该节点,并唤醒该节点等待的线程,被唤醒的消费者线程取走元素。
maximumPoolSize
(线程池最大大小):线程池允许创建的最大线程数。如果队列满了,并且已创建的线程数小于最大线程数,则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列这个参数就没什么效果。maximumPoolSize
(线程池最大大小):线程池允许创建的最大线程数。如果队列满了,并且已创建的线程数小于最大线程数,则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列这个参数就没什么效果。ThreadFactory
:用于设置创建线程的工厂,可以通过线程工厂给每个创建出来的线程设置更有意义的名字,Debug和定位问题时非常又帮助。RejectedExecutionHandler
(饱和策略):当队列和线程池都满了,说明线程池处于饱和状态,那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy
,表示无法处理新任务时抛出异常。以下是JDK1.5提供的四种策略:AbortPolicy
(默认): 丢弃任务并抛出RejectedExecutionException
异常。CallerRunsPolicy
:只用调用者所在线程来运行任务。DiscardOldestPolicy
:丢弃队列里最早进入一个任务,并执行当前任务。将当前处于等待队列列头
的等待任务强行取出,然后再试图将当前被拒绝的任务提交到线程池执行。DiscardPolicy
:不处理,丢弃掉。- 自定义策略:当然也可以根据应用场景需要来实现
RejectedExecutionHandler
接口自定义策略。如记录日志或持久化不能处理的任务。
keepAliveTime
(线程活动保持时间):线程池的工作线程空闲后,保持存活的时间。所以如果任务很多,并且每个任务执行的时间比较短,可以调大这个时间,提高线程的利用率。TimeUnit
(线程活动保持时间的单位):可选的单位有天(DAYS
),小时(HOURS
),分钟(MINUTES
),毫秒(MILLISECONDS
),微秒(MICROSECONDS
, 千分之一毫秒)和毫微秒(NANOSECONDS
, 千分之一微秒)
自定义连接池稍微麻烦些,不过通过创建的ThreadPoolExecutor
线程池对象,可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等
具体示例:
ThreadPoolExecutor thread
= new ThreadPoolExecutor(1, 5, 5, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(),
new ThreadFactoryBuilder().setNamePrefix("Pool-" + "线程名字").setDaemon(false).build(),
new ThreadPoolExecutor.CallerRunsPolicy());
2.1.2 通过Executors方式创建
Java
通过Executors
(jdk1.5并发包)提供四种线程池,分别为:
newCachedThreadPool
:创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程
ExecutorService pool = Executors.newCachedThreadPool();
newFixedThreadPool
:创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待
ExecutorService pool = Executors.newFixedThreadPool(2);
newScheduledThreadPool
:创建一个定长线程池,支持定时及周期性任务执行
ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
将线程放入池中进行执行
pool.execute(new MyThread());
使用延迟执行风格的方法
pool.schedule(new MyThread(), 10, TimeUnit.MILLISECONDS);
class MyThread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "正在执行。。。");
}
}
newSingleThreadExecutor
:创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
ExecutorService pool = Executors.newSingleThreadExecutor();
2.1.3 线程池初始化和容量调整
默认情况下,创建线程池之后,线程池中是没有线程的,需要提交任务之后才会创建线程。
在实际中如果需要线程池创建之后立即创建线程,可以通过以下两个方法办到:
prestartCoreThread()
:boolean prestartCoreThread()
,初始化一个核心线程prestartAllCoreThreads()
:int prestartAllCoreThreads()
,初始化所有核心线程,并返回初始化的线程数
线程池容量调整
ThreadPoolExecutor
提供了动态调整线程池容量大小的方法:
setCorePoolSize
:设置核心池大小setMaximumPoolSize
:设置线程池最大能创建的线程数目大小
当上述参数从小变大时,ThreadPoolExecutor
进行线程赋值,还可能立即创建新的线程来执行任务。
2.2 线程池提交的返回值
2.2.1 无返回值
2.2.1.1 execute提交
可以使用execute
提交的任务,但是execute
方法没有返回值,所以无法判断任务是否被线程池执行成功。通过以下代码可知execute
方法输入的任务是一个Runnable
类的实例
threadsPool.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
});
2.2.1.2 实现Runnable接口
无返回值的任务必须Runnable
接口重写run
方法,方法的异常只能在内部消化,不能继续上抛
2.2.2 有返回值
2.2.2.1 submit提交
我们也可以使用submit
方法来提交任务,它会返回一个future
,那么我们可以通过这个future
来判断任务是否执行成功,通过future
的get
方法来获取返回值, get方法会阻塞住直到任务完成
,而使用get(long timeout, TimeUnit unit)
方法则会阻塞一段时间后立即返回,这时有可能任务没有执行完。
try {
Object s = future.get();
} catch (InterruptedException e) {
// 处理中断异常
} catch (ExecutionException e) {
// 处理无法执行任务异常
} finally {
// 关闭线程池
executor.shutdown();
}
2.2.2.2 实现Callable接口
返回值的任务必须实现Callable
接口重写call
方法且方法允许抛出异常
要想有返回值,那么submit
的组合:
submit(Callable<T> task)
能获取到它的返回值,通过future.get()
获取(阻塞直到任务执行完)。一般使用FutureTask+Callable
配合使用submit(Runnable task, T result)
能通过传入的载体result
间接获得线程的返回值。submit(Runnable task)
则是没有返回值的,就算获取它的返回值也是null
2.2.3 使用例子
public void testFuture() throws InterruptedException {
ExecutorService executor = Executors.newCachedThreadPool();
Task task = new Task();
NewTask newTask = new NewTask();
Future<Integer> result = executor.submit(task);
Future<String> ends = executor.submit(newTask);
executor.shutdown();
System.out.println("主线程开始运行");
System.out.println("主线程做一些复杂任务");
Thread.sleep(10000);
System.out.println("主线程需要子线程的计算结果");
try {
System.out.println("主线程得到子线程的结果:"+result.get());
System.out.println("主线程需要第二个子线程的数据:"+ends.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("所有均完毕");
}
class Task implements Callable<Integer>{
public Integer call() throws Exception {
System.out.println("子线程计算开始");
Thread.sleep(3000);
int sum = 0;
for (int i=0;i<100000;i++){
sum += i ;
}
System.out.println("子线程已经计算完毕");
return sum;
}
}
class NewTask implements Callable<String>{
public String call() throws Exception {
System.out.println("第二个子线程已经运行完毕");
return "success";
}
}
2.2.4 invokeAll和invokeAny
invokeAll
和invokeAny
区别:
invokeAll
触发执行任务列表,返回的结果顺序也与任务在任务列表中的顺序一致。所有线程执行完任务后才返回结果。如果设置了超时时间,未超时完成则正常返回结果,如果超时未完成则报异常。invokeAny
将第一个得到的结果作为返回值,然后立刻终止所有的线程。如果设置了超时时间,未超时完成则正常返回结果,如果超时未完成则报超时异常
submit
、execute
、invokeAll
和invokeAny
区别:
invallkeAll
和invokeAny
会直接造成主线程阻塞(需要设置超时时间)。等待所有任务执行完成后返回结果,主线程继续执行。submit
不会造成主线程阻塞,在后面执行get
方法的时候阻塞。超时时间在get
里面设置。execute
会新开启线程直接执行任务,不会阻塞主线程,但无返回结果
2.3 线程池的关闭
我们可以通过调用线程池的shutdown
或shutdownNow
方法来关闭线程池,但是它们的实现原理不同:
shutdown
的原理是只是将线程池的状态设置成SHUTDOWN
状态,然后 中断所有没有正在执行任务的线程
。
shutdownNow
的原理是遍历线程池中的工作线程,然后逐个调用线程的interrupt
方法来中断线程,所以无法响应中断的任务可能永远无法终止。shutdownNow
会首先将线程池的状态设置成STOP
,然后尝试停止所有的正在执行或暂停任务的线程,并返回等待执行任务的列表。
只要调用了这两个关闭方法的其中一个,isShutdown
方法就会返回true
。当所有的任务都已关闭后,才表示线程池关闭成功,这时调用isTerminaed
方法会返回true
。至于我们应该调用哪一种方法来关闭线程池,应该由提交到线程池的任务特性决定,通常调用shutdown
来关闭线程池,如果任务不一定要执行完,则可以调用shutdownNow
。
2.4 线程池状态分析
线程池和线程的状态是不一样的哈,线程池有这几个状态:RUNNING
,SHUTDOWN
,STOP
,TIDYING
,TERMINATED
//线程池状态
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;
线程池各个状态切换状态图如下:
RUNNING
该状态的线程池会接收新任务,并处理阻塞队列中的任务;
调用线程池的shutdown()
方法,可以切换到SHUTDOWN
状态;
调用线程池的shutdownNow()
方法,可以切换到STOP
状态;SHUTDOWN
该状态的线程池不会接收新任务,但会处理阻塞队列中的任务;
队列为空,并且线程池中执行的任务也为空,进入TIDYING
状态;STOP
该状态的线程不会接收新任务,也不会处理阻塞队列中的任务,而且会中断正在运行的任务;
线程池中执行的任务为空,进入TIDYING
状态;TIDYING
该状态表明所有的任务已经运行终止,记录的任务数量为0。
terminated()
执行完毕,进入TERMINATED
状态TERMINATED
该状态表示线程池彻底终止
3 线程池的分析
3.1 流程分析
Java线程池主要工作流程:
当提交一个新任务到线程池时,线程池的处理流程如下:
- 首先线程池判断
基本线程池
是否已满?没满,创建一个工作线程来执行任务。满了,则进入下个流程。 - 其次线程池判断
工作队列
是否已满?没满,则将新提交的任务存储在工作队列里。满了,则进入下个流程。 - 最后线程池判断
整个线程池
是否已满?没满,则创建一个新的工作线程来执行任务,满了,则交给饱和策略来处理这个任务。
另外:当线程池中超过corePoolSize
线程,空闲时间达到keepAliveTime
时,关闭空闲线程
线程池内线程数量小于等于coreSize
的部分称为核心池,核心池是线程池的常驻部分,内部的线程一般不会被销毁,我们提交的任务也应该绝大部分都由核心池内的线程来执行,但是当设置allowCoreThreadTimeOut(true)
时,线程池中corePoolSize
线程空闲时间达到keepAliveTime
也将关闭
3.2 源码分析
上面的流程分析让我们很直观的了解的线程池的工作原理,让我们再通过源代码来看看是如何实现的。线程池执行任务的方法如下:
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//如果线程数小于基本线程数,则创建线程并执行当前任务
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
//如线程数大于等于基本线程数或线程创建失败,则将当前任务放到工作队列中。
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
}
//如果线程池不处于运行中或任务无法放入队列,并且当前线程数量小于最大允许的线程数量,则创建一个线程执行任务。
else if (!addIfUnderMaximumPoolSize(command))
//抛出RejectedExecutionException异常
reject(command); // is shutdown or saturated
}
}
工作线程
线程池创建线程时,会将线程封装成工作线程Worker
,Worker
在执行完任务后,还会无限循环获取工作队列里的任务来执行。我们可以从Worker
的run
方法里看到这点:
public void run() {
try {
Runnable task = firstTask;
firstTask = null;
while (task != null || (task = getTask()) != null) {
runTask(task);
task = null;
}
} finally {
workerDone(this);
}
}
3.3 解读线程池
我们知道,向线程池提交任务是用ThreadPoolExecutor的execute()
方法,但在其内部,线程任务的处理其实是相当复杂的,涉及到ThreadPoolExecutor、Worker、Thread
三个类的6个方法:
源码解读部分参考链接
3.3.1 execute()
在ThreadPoolExecutor
类中,任务提交方法的入口是execute(Runnable command)
方法(submit()方法也是调用了execute()),该方法其实只在尝试做一件事:经过各种校验之后,调用 addWorker(Runnable command,boolean core)
方法为线程池创建一个线程并执行任务,与之相对应,execute()的结果有两个:
参数说明:
Runnable command
:待执行的任务
执行流程:
- 通过
ctl.get()
得到线程池的当前线程数,如果线程数小于corePoolSize
,则调用addWorker(commond,true)
方法创建新的线程执行任务,否则执行步骤2; - 步骤1失败,说明已经无法再创建新线程,那么考虑将任务放入阻塞队列,等待执行完任务的线程来处理。基于此,判断线程池是否处于
Running
状态(只有Running
状态的线程池可以接受新任务),如果任务添加到任务队列成功则进入步骤3,失败则进入步骤4; - 来到这一步需要说明任务已经加入任务队列,这时要二次校验线程池的状态,会有以下情形:
- 线程池不再是
Running
状态了,需要将任务从任务队列中移除,如果移除成功则拒绝本次任务 - 线程池是
Running
状态,则判断线程池工作线程是否为0,是则调用addWorker(commond,true)
添加一个没有初始任务的线程(这个线程将去获取已经加入任务队列的本次任务并执行),否则进入步骤4; - 线程池不是
Running
状态,但从任务队列移除任务失败(可能已被某线程获取?),进入步骤4;
- 线程池不再是
- 将线程池扩容至
maximumPoolSize
并调用addWorker(commond,false)
方法创建新的线程执行任务,失败则拒绝本次任务。
流程图:
3.3.2 addWorker()
addWorker(Runnable firstTask, boolean core)
方法,顾名思义,向线程池添加一个带有任务的工作线程。
参数说明:
Runnable firstTask
:新创建的线程应该首先运行的任务(如果没有,则为空)。boolean core
:该参数决定了线程池容量的约束条件,即当前线程数量以何值为极限值。参数为true
则使用corePollSize
作为约束值,否则使用maximumPoolSize
。
执行流程:
- 外层循环判断线程池的状态是否可以新增工作线程。这层校验基于下面两个原则:
- 线程池为
Running
状态时,既可以接受新任务也可以处理任务 - 线程池为关闭状态时只能新增空任务的工作线程(
worker
)处理任务队列(workQueue
)中的任务不能接受新任务
- 线程池为
- 内层循环向线程池添加工作线程并返回是否添加成功的结果。
- 首先校验线程数是否已经超限制,是则返回
false
,否则进入下一步 - 通过
CAS
使工作线程数+1
,成功则进入步骤3,失败则再次校验线程池是否是运行状态,是则继续内层循环,不是则返回外层循环
- 首先校验线程数是否已经超限制,是则返回
- 核心线程数量+1成功的后续操作:添加到工作线程集合,并启动工作线程
- 首先获取锁之后,再次校验线程池状态(具体校验规则见代码注解),通过则进入下一步,未通过则添加线程失败
- 线程池状态校验通过后,再检查线程是否已经启动,是则抛出异常,否则尝试将线程加入线程池
检查线程是否启动成功,成功则返回true,失败则进入addWorkerFailed
方法
流程图:
3.3.3 Worker类
Worker
类是内部类,既实现了Runnable
,又继承了AbstractQueuedSynchronizer
(以下简称AQS
),所以其既是一个可执行的任务,又可以达到锁的效果。
Worker
类主要维护正在运行任务的线程的中断控制状态,以及其他次要的记录。这个类适时地继承了AbstractQueuedSynchronizer
类,以简化获取和释放锁(该锁作用于每个任务执行代码)的过程。这样可以防止去中断正在运行中的任务,只会中断在等待从任务队列中获取任务的线程。
我们实现了一个简单的不可重入互斥锁,而不是使用可重入锁,因为我们不希望工作任务在调用setCorePoolSize
之类的池控制方法时能够重新获取锁。另外,为了在线程真正开始运行任务之前禁止中断,我们将锁状态初始化为负值,并在启动时清除它(在runWorker中)。
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
/**
* This class will never be serialized, but we provide a
* serialVersionUID to suppress a javac warning.
*/
private static final long serialVersionUID = 6138294804551838833L;
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;
/** Initial task to run. Possibly null. */
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
// 通过构造函数初始化,
Worker(Runnable firstTask) {
//设置AQS的同步状态
// state:锁状态,-1为初始值,0为unlock状态,1为lock状态
setState(-1); // inhibit interrupts until runWorker 在调用runWorker前,禁止中断
this.firstTask = firstTask;
// 线程工厂创建一个线程
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this); //runWorker()是ThreadPoolExecutor的方法
}
// Lock methods
// The value 0 represents the unlocked state. 0代表“没被锁定”状态
// The value 1 represents the locked state. 1代表“锁定”状态
protected boolean isHeldExclusively() {
return getState() != 0;
}
/**
* 尝试获取锁的方法
* 重写AQS的tryAcquire(),AQS本来就是让子类来实现的
*/
protected boolean tryAcquire(int unused) {
// 判断原值为0,且重置为1,所以state为-1时,锁无法获取。
// 每次都是0->1,保证了锁的不可重入性
if (compareAndSetState(0, 1)) {
// 设置exclusiveOwnerThread=当前线程
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
/**
* 尝试释放锁
* 不是state-1,而是置为0
*/
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
/**
* 中断(如果运行)
* shutdownNow时会循环对worker线程执行
* 且不需要获取worker锁,即使在worker运行时也可以中断
*/
void interruptIfStarted() {
Thread t;
//如果state>=0、t!=null、且t没有被中断
//new Worker()时state==-1,说明不能中断
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
3.3.4 runWorker()
可以说,runWorker(Worker w)
是线程池中真正处理任务的方法,前面的execute()
和 addWorker()
都是在为该方法做准备和铺垫。
参数说明:
Worker w
:封装的Worker
,携带了工作线程的诸多要素,包括Runnable
(待处理任务)、lock
(锁)、completedTasks
(记录线程池已完成任务数)
执行流程:
- 判断当前任务或者从任务队列中获取的任务是否不为空,都为空则进入步骤2,否则进入步骤3
- 任务为空,则将
completedAbruptly
置为false
(即线程不是突然终止),并执行processWorkerExit(w,completedAbruptly)
方法进入线程退出程序 - 任务不为空,则进入循环,并加锁
- 判断是否为线程添加中断标识,以下两个条件满足其一则添加中断标识:
- 线程池状态>=
STOP
,即STOP或TERMINATED
- 一开始判断线程池状态<
STOP
,接下来检查发现Thread.interrupted()为true
,即线程已经被中断,再次检查线程池状态是否>=STOP
(以消除该瞬间shutdown方法生效,使线程池处于STOP或TERMINATED)
- 线程池状态>=
- 执行前置方法
beforeExecute(wt, task)
(该方法为空方法,由子类实现)后执行task.run()
方法执行任务(执行不成功抛出相应异常) - 执行后置方法
afterExecute(task, thrown)
(该方法为空方法,由子类实现)后将线程池已完成的任务数+1,并释放锁。 - 再次进行循环条件判断。
流程图:
3.3.5 getTask()
由函数调用关系图可知,在ThreadPoolExecutor
类的实现中,Runnable getTask()
方法是为void runWorker(Worker w)
方法服务的,它的作用就是在任务队列(workQueue)中获取 task(Runnable)
参数说明:无参数
执行流程:
- 将
timedOut
(上次获取任务是否超时)置为false
(首次执行方法,无上次,自然为false),进入一个无限循环 - 如果线程池为
Shutdown
状态且任务队列为空(线程池shutdown
状态可以处理任务队列中的任务,不再接受新任务,这个是重点)或者线程池为STOP或TERMINATED
状态,则意味着线程池不必再获取任务了,当前工作线程数量-1并返回null,否则进入步骤3 - 如果线程池数量超限制或者时间超限且(任务队列为空或当前线程数>1),则进入步骤4,否则进入步骤5。
- 移除工作线程,成功则返回null,不成功则进入下轮循环。
- 尝试用
poll() 或者 take()
(具体用哪个取决于timed的值)获取任务,如果任务不为空,则返回该任务。如果为空,则将timeOut
置为true
进入下一轮循环。如果获取任务过程发生异常,则将 timeOut置为 false 后进入下一轮循环。
流程图:
3.3.6 processWorkerExit()
processWorkerExit(Worker w, boolean completedAbruptly)
执行线程退出的方法
参数说明:
Worker w
:要结束的工作线程。boolean completedAbruptly
:是否突然完成(异常导致),如果工作线程因为用户异常死亡,则completedAbruptly
参数为true
。
执行流程:
- 如果
completedAbruptly 为 true
,即工作线程因为异常突然死亡,则执行工作线程-1操作。 - 主线程获取锁后,线程池已经完成的任务数追加 w(当前工作线程) 完成的任务数,并从
worker
的set集合中移除当前worker。 - 根据线程池状态进行判断是否执行
tryTerminate()
结束线程池。 - 是否需要增加工作线程,如果线程池还没有完全终止,仍需要保持一定数量的线程。
- 如果当前线程是突然终止的,调用
addWorker()
创建工作线程 - 当前线程不是突然终止,但当前工作线程数量小于线程池需要维护的线程数量,则创建工作线程。需要维护的线程数量为
corePoolSize
(取决于成员变量allowCoreThreadTimeOut
是否为false
)或1。
- 如果当前线程是突然终止的,调用
4 合理的配置线程池
4.1 线程池分析
要想合理的配置线程池,就必须首先分析任务特性,可以从以下几个角度来进行分析:
任务的性质
:CPU
密集型任务,IO
密集型任务和混合型任务。任务的优先级
:高,中和低。任务的执行时间
:长,中和短。任务的依赖性
:是否依赖其他系统资源,如数据库连接。
任务性质不同的任务可以用不同规模的线程池分开处理。CPU
密集型任务配置尽可能少的线程数量,如配置Ncpu+1
个线程的线程池。IO
密集型任务则由于需要等待IO
操作,线程并不是一直在执行任务,则配置尽可能多的线程,如2*Ncpu
。混合型的任务,如果可以拆分,则将其拆分成一个CPU
密集型任务和一个IO
密集型任务,只要这两个任务执行的时间相差不是太大,那么分解后执行的吞吐率要高于串行执行的吞吐率,如果这两个任务执行时间相差太大,则没必要进行分解。我们可以通过Runtime.getRuntime().availableProcessors()
方法获得当前设备的CPU
个数。
优先级不同的任务可以使用优先级队列PriorityBlockingQueue
来处理。它可以让优先级高的任务先得到执行,需要注意的是如果一直有优先级高的任务提交到队列里,那么优先级低的任务可能永远不能执行。
执行时间不同的任务可以交给不同规模的线程池来处理,或者也可以使用优先级队列,让执行时间短的任务先执行。
依赖数据库连接池的任务,因为线程提交SQL
后需要等待数据库返回结果,如果等待的时间越长CPU
空闲时间就越长,那么线程数应该设置越大,这样才能更好的利用CPU
。
4.2 有界队列
建议使用有界队列,有界队列能增加系统的稳定性和预警能力,可以根据需要设大一点,比如几千。有一次使用的后台任务线程池的队列和线程池全满了,不断的抛出抛弃任务的异常,通过排查发现是数据库出现了问题,导致执行SQL变得非常缓慢,因为后台任务线程池里的任务全是需要向数据库查询和插入数据的,所以导致线程池里的工作线程全部阻塞住,任务积压在线程池里。如果当时我们设置成无界队列,线程池的队列就会越来越多,有可能会撑满内存,导致整个系统不可用,而不只是后台任务出现问题
5 线程池的监控
5.1 通过线程池提供参数监控
线程池里有一些属性在监控线程池的时候可以使用:
taskCount
:线程池需要执行的任务数量。completedTaskCount
:线程池在运行过程中已完成的任务数量。小于或等于taskCount
largestPoolSize
:线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小,则表示线程池曾经满了。getPoolSize
:线程池的线程数量。如果线程池不销毁的话,池里的线程不会自动销毁,所以这个大小只增不减。getActiveCount
:获取活动的线程数。
5.2 通过扩展线程池进行监控
通过继承线程池并重写线程池的beforeExecute
,afterExecute
和terminated
方法,我们可以在任务执行前
,执行后
和线程池关闭前
干一些事情。如监控任务的平均执行时间,最大执行时间和最小执行时间等。这几个方法在线程池里是空方法。如:
protected void beforeExecute(Thread t, Runnable r) { }
附:Spring线程池ThreadPoolTaskExecutor的使用
6 线程组
6.1 线程组定义
可以把线程归属到某一个线程组中,线程组中可以有线程对象
,也可以有线程组
,组中还可以有线程,这样的组织结构有点类似于树的形式,如图所示.
线程组的作用是:可以批量管理线程或线程组对象,有效地对线程或线程组对象进行组织
相关构造方法:
ThreadGroup(String name)
:构造一个新线程组ThreadGroup(ThreadGroup parent,String name)
:构造一个新线程组
注意一下第二个,假如要使用多级关联一般就是用第二个构造函数。第一个参数表示新线程组的父线程组,第二个参数表示新线程组的名称,有了父线程组和新线程组的名称,自然可以构造出一个新的线程组来了。
注意
:线程必须启动后才能归到指定线程组中
6.2 使用操作
ThreadGroup
其实比ExecutorService
更好
用java做抓取的时候免不了要用到多线程的了,因为要同时抓取多个网站或一条线程抓取一个网站的话实在太慢,而且有时一条线程抓取同一个网站的话也比较浪费CPU资源。要用到多线程的等方面,也就免不了对线程的控制或用到线程池
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
public class JavaThreadPool {
public static void main(String[] args) {
// 创建一个可重用固定线程数的线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
// 创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口
Thread t1 = new MyThread();
Thread t2 = new MyThread();
Thread t3 = new MyThread();
Thread t4 = new MyThread();
Thread t5 = new MyThread();
// 将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
// 关闭线程池
pool.shutdown();
}
}
class MyThread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "正在执行。。。");
}
}
后来发现ExecutorService的功能没有想像中的那么好,而且最多只是提供一个线程的容器而然,所以后来改用了java.lang.ThreadGroup,ThreadGroup有很多优势,最重要的一点就是它可以对线程进行遍历,知道那些线程已经运行完毕,还有那些线程在运行。关于ThreadGroup的使用代码如下:
class MyThread extends Thread {
boolean stopped;
MyThread(ThreadGroup tg, String name) {
super(tg, name);
stopped = false;
}
public void run() {
System.out.println(Thread.currentThread().getName() + " starting.");
try {
for (int i = 1; i < 1000; i++) {
System.out.print(".");
Thread.sleep(250);
synchronized (this) {
if (stopped)break;
}
}
} catch (Exception exc) {
System.out.println(Thread.currentThread().getName() + " interrupted.");
}
System.out.println(Thread.currentThread().getName() + " exiting.");
}
synchronized void myStop() {
stopped = true;
}
}
public class Main {
public static void main(String args[]) throws Exception {
ThreadGroup tg = new ThreadGroup("My Group");
MyThread thrd = new MyThread(tg, "MyThread #1");
MyThread thrd2 = new MyThread(tg, "MyThread #2");
MyThread thrd3 = new MyThread(tg, "MyThread #3");
thrd.start();
thrd2.start();
thrd3.start();
Thread.sleep(1000);
System.out.println(tg.activeCount() + " threads in thread group.");
Thread thrds[] = new Thread[tg.activeCount()];
tg.enumerate(thrds);
for (Thread t : thrds)
System.out.println(t.getName());
thrd.myStop();
Thread.sleep(1000);
System.out.println(tg.activeCount() + " threads in tg.");
tg.interrupt();
}
}
由以上的代码可以看出:ThreadGroup比ExecutorService多以下几个优势
ThreadGroup
可以遍历线程,知道那些线程已经运行完毕,那些还在运行- 可以通过
ThreadGroup.activeCount
知道有多少线程从而可以控制插入的线程数
6.3 和线程池区别
线程组和线程池区别:
- 线程组:
线程组存在的意义,首要原因是安全
java
默认创建的线程都是属于系统线程组
,而同一个线程组的线程是可以相互修改对方的数据的。
但如果在不同的线程组中,那么就不能跨线程组
修改数据,可以从一定程度上保证数据安全。 - 线程池:
线程池存在的意义,首要作用是效率
线程的创建和结束都需要耗费一定的系统时间(特别是创建),不停创建和删除线程会浪费大量的时间。所以,在创建出一条线程并使其在执行完任务后不结束,而是使其进入休眠状态,在需要用时再唤醒,那么 就可以节省一定的时间。
如果这样的线程比较多,那么就可以使用线程池来进行管理。保证效率。 - 线程组和线程池共有的特点:
都是管理一定数量的线程
都可以对线程进行控制---包括休眠,唤醒,结束,创建,中断(暂停)--但并不一定包含全部这些操作。