文章目录
1、类继承关系
ThreadPoolExecutor和ScheduleThreadPoolExecutor的继承结构
(可以通过IDEA,在类中使用Ctrl + H进行查看)
2、ThreadPoolExecutor
2.1、ThreadPoolExecutor构造器
2.2、ThreadPoolExecutor核心方法
submit(Runnable):提交任务
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask); //核心:调用execute方法
return ftask;
}
execute(task):线程池执行任务的核心方法
/**
* Executes the given task sometime in the future. The task
* may execute in a new thread or in an existing pooled thread.
*
* If the task cannot be submitted for execution, either because this
* executor has been shutdown or because its capacity has been reached,
* the task is handled by the current {@code RejectedExecutionHandler}.
*
* @param command the task to execute
* @throws RejectedExecutionException at discretion of
* {@code RejectedExecutionHandler}, if the task
* cannot be accepted for execution
* @throws NullPointerException if {@code command} is null
*/
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
解析:
- 如果线程池中,核心线程有空闲线程资源,则直接使用核心线程执行任务;
(核心线程数:corePoolSize) - 如果核心线程都在运行中,则将任务放入等待队列(workQueue);
- 如果等待队列已经被放满,且当前线程数少于线程池最大线程数(maximumPoolSize)时,会使用线程工厂(threadFactory)开启新的线程执行任务;
新开启的线程不会一直存在,当达到一定时间(keepAliveTime,unit)没有执行任务(处于空闲状态)时,则线程会被销毁 - 如果当前线程数已经达到了线程池的最大线程数,则执行拒绝策略(handler),拒绝任务。
shutdown():终止线程池
shutdown之后不会再接受任务,直接执行拒绝策略
已经提交的任务,会继续完成,然后终止线程池
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
shutdownNow():立即终止线程池
与shutdown不一样的是: 正在运行中的任务,会被调用interrupted,终止线程
然后返回线程池队列的任务
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(STOP);
interruptWorkers();
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
2.3、重点:如何正确设定线程池的线程数量
- 计算型任务:cpu数量的1-2倍
- IO型任务:要根据具体的IO阻塞时长进行考量决定,可以多开线程进行并发执行
也可以考虑根据需要在一个最小数量和最大数量间自动增减线程数
可以检测CPU的使用率检测线程数量是否足够。一般CPU使用率达到80%左右是最好的,如果少于80%可以多开线程,如果多于80%,说明线程数量过多,可以适当减少。
3、ScheduleThreadPoolExecutor
本质相当于把任务添加到延迟队列,即没有到达规定时间,任务无法被取出进行处理
3.1、ScheduleThreadPoolExecutor构造器
3.2、ScheduleThreadPoolExecutor重要方法
schedule:相当于js的setTimeout,执行一次
scheduleAtFixedRate & scheduleWithFixedDelay:
区别:
如果是间隔3秒执行一次,一个任务需要1秒,那scheduleAtFixedRate和scheduleWithFixedDelay没有区别;
不会在同一时间有并发执行,会等待
FixedRate,如果间隔1秒执行一次,但一个任务需要3秒,上一个任务执行完直接开始下一次执行;
FixedDelay,如果间隔1秒执行一次,但一个任务需要3秒,上一次任务执行完,等待一个周期(即1秒),再进行下一次执行。
根据业务流程选择,一般建议使用scheduleAtFixedRate。
4、Executors
Executors:用于创建线程池的工具类,提供多种线程池的创建方法。
不建议直接使用Executors创建线程池,但可以参考Executors的方法,使用ThreadPoolExecutor构造器创建线程池
- newCachedThreadPool:无法预估,动态因素比较多的时候使用
要注意,不会控制线程数量的大小,如果线程过多,也会出现卡顿
建议自己设定最大线程数,可以设置为1000/10000,可以是一个比较大的数
没有核心线程数,可以无限创建线程
- newFixedThreadPool:
理论上等待队列可以无限大,即不可能出现加开线程的情况。但是如果出现大量堆积的情况的话,即使加开线程也没有办法解决,应该去检查代码是否有问题。
最大线程数和核心线程数一样,不允许加开线程,等待队列可以无限大
- newScheduleThreadPool:创建定时线程池
- newSingleThreadExecutor:创建单线程线程池