本文主要讲解java中线程池的。
前言
Executor框架是一个根据一组执行策略调用,调度,执行和控制的异步任务的框架,目的是提供一种将”任务提交”与”任务运行”分离开来的机制。
继承体系
- Executor
- void execute(Runnable command)。
- ExecutorService 接口在其父类接口基础上,
- void shutdown(); 启动有序关闭,在该关闭中将执行先前提交的*任务,但将不接受任何新任务。 , *如果调用已经关闭,则调用不会产生任何其他影响。
- List shutdownNow(); 尝试停止所有正在执行的任务,暂停正在等待的任务的处理,并返回正在等待执行的任务的列表。 , * *
此方法不等待正在执行的任务终止。, 使用{@link #awaitTermination awaitTermination}进行*。 , * *
除了尽力而为之外,不能保证停止处理正在执行的任务。, 例如,典型的*实现将通过{@link Thread#interrupt}取消,因此任何无法响应中断的任务都可能永远不会终止。
- invokeAll、
- invokeAny 等方法。
- Future submit(Callable task); 提交一个执行返回值的任务,并返回一个* Future,表示任务的未决结果。 , * Future的{@code get}方法将在成功完成后返回任务的结果。 如果您想立即阻止等待某项任务,则可以使用* {@code result = exec.submit(aCallable).get();}形式的构造
- Future<?> submit(Runnable task);
- ScheduledExecutorService 接口,
- 则是声明了一些和定时任务相关的方法,比如 schedule和scheduleAtFixedRate。
- 线程池的核心实现是在 ThreadPoolExecutor 类中,
- 我们使用 Executors 调用newFixedThreadPool、newSingleThreadExecutor和newCachedThreadPool等方法创建线程池均是 ThreadPoolExecutor 类型。
核心参数
在说线程池原理或者机制之前,首先需要了解一下构建线程池过程中需要配置的那些参数。
- corePoolSize:核心线程数,cpu+1;表示核心线程池的大小。
- 当提交一个任务时,如果当前核心线程池的线程个数没有达到corePoolSize,则会创建新的线程来执行所提交的任务,即使当前核心线程池有空闲的线程。如果当前核心线程池的线程个数已经达到了corePoolSize,则不再重新创建线程。如果调用了prestartCoreThread()或者 prestartAllCoreThreads(),线程池创建的时候所有的核心线程都会被创建并且启动。
- maxPoolSize:最大线程数。
- 当线程池里面的线程数超过corePoolSize,小于maximumPoolSize时会动态创建与回收线程池里面的线程池资源。
- long keepAliveTime:空闲线程存活时间。表示线程没有执行任务时最多保持多久时间会终止。
- 默认情况下,只有当线程池中的线程数大于corePoolSize时,keepAliveTime才会生效,直到线程池数量不大于corePoolSize,即只有当线程池数量大于corePoolSize数量,超出这个数量的线程一旦到达keepAliveTime就会终止。但是如果调用了allowCoreThreadTimeout(boolean)方法,即使线程池的线程数量不大于corePoolSize,线程也会在keepAliveTime之后就终止,知道线程池的数量为0为止。
- TimeUnit unit:参数keepAliveTime的时间单位,一个时间单位枚举类。
- BlockingQueue:一个阻塞队列,用来存储等待执行任务的队列。
- 这个参数选择也很重要,会对线程池的运行过程产生重大影响,一般来说,这里的阻塞队列就是(ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue;用于保存任务的阻塞队列,关于阻塞队列可以看这篇文章。可以使用ArrayBlockingQueue, LinkedBlockingQueue, SynchronousQueue, PriorityBlockingQueue。
- RejectExecutionHandler:线程池的拒绝策略
- AbortPolicy:一言不合就抛异常(默认使用策略)。
- CallerRunsPolicy:只用调用者所在线程来运行任务。
- DiscardOldestPolicy:丢弃队列里最近的一个任务,并执行当前任务。
- DiscardPolicy:不处理,直接丢弃。
流程图
资源回收
考虑到系统资源是有限的,对于线程池超出 corePoolSize 数量的空闲线程应进行回收操作。进行此操作存在一个问题,即回收时机。
目前的实现方式是当线程空闲时间超过 keepAliveTime 后,进行回收。除了核心线程数之外的线程可以进行回收,核心线程内的空闲线程也可以进行回收。回收的前提是allowCoreThreadTimeOut属性被设置为 true,
通过public void allowCoreThreadTimeOut(boolean)方法可以设置属性值。
优缺点
- 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
- 提高响应速度。当任务到达时,任务可以不需要的等到线程创建就能立即执行。
- 提高线程的可管理性。线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。
四种常见线程池
Java通过Executors提供四种线程池
- newCachedThreadPool:new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue()); 创建一个根据需要创建新线程的线程池,但将在以前构造的线程可用时重用它们。, 这些池通常会提高执行许多短期异步任务的程序的性能。 , 调用{@code execute}将重用以前构造的线程(如果可用)。, 如果没有可用的现有线程,则将创建一个新的线程并将其添加到池中。, 具有未使用60秒的线程将终止并从缓存中删除。, 因此,长时间闲置的池将不会消耗任何资源。, 请注意,可以使用{@link ThreadPoolExecutor}构造函数创建具有类似*属性但具有不同详细信息(例如,超时参数)*的池。
- newFixedThreadPool(num):new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), threadFactory);创建一个线程池,该线程池重用固定数量的线程在共享的无界队列*中运行,使用提供的* ThreadFactory在需要时创建新线程。, 在任何时候,最多{@code nThreads}线程将是活动处理任务。, 如果在所有线程都处于活动状态时提交了其他任务,则它们将在队列中等待,直到线程可用。, 如果任何线程在关闭之前的执行期间由于故障而终止,则如果*需要执行后续任务,则新线程将取代它。, 池中的线程将存在,直到它显式{@link ExecutorService#shutdown * shutdown}。
- newScheduledThreadPool:创建一个单线程执行程序,可以调度命令在给定延迟后运行,或定期执行。 , (但请注意,如果由于在关闭之前执行期间出现故障而导致此单个线程终止,则在执行后续任务时,如果需要执行后续任务,则将使用新的。)任务保证按顺序执行*,并且不超过, 一个任务将在任何给定时间激活。, 与其他等效的 {@code newScheduledThreadPool(1)}不同,返回的执行程序*保证不可重新配置以使用其他线程。 , * @return新创建的预定执行人。支持定时及周期性任务执行。
- newSingleThreadExecutor:new ThreadPoolExecutor(1, 1, 0L,TimeUnit.MILLISECONDS, new LinkedBlockingQueue())创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
线程池的关闭
- 关闭线程池,可以通过shutdown和shutdownNow这两个方法。它们的原理都是遍历线程池中所有的线程,然后依次中断线程。shutdown和shutdownNow还是有不一样的地方:
- shutdownNow首先将线程池的状态设置为STOP,然后尝试停止所有的正在执行和未执行任务的线程,并返回等待执行任务的列表;
- shutdown只是将线程池的状态设置为SHUTDOWN状态,然后中断所有没有正在执行任务的线程
如何合理配置线程池参数?
任务性质不同的任务可以用不同规模的线程池分开处理。
-
CPU密集型任务配置尽可能少的线程数量,如配置Ncpu+1个线程的线程池。
-
IO密集型任务则由于需要等待IO操作,线程并不是一直在执行任务,则配置尽可能多的线程,如2xNcpu。
-
混合型的任务,如果可以拆分,则将其拆分成一个CPU密集型任务和一个IO密集型任务,只要这两个任务执行的时间相差不是太大,那么分解后执行的吞吐率要高于串行执行的吞吐率,如果这两个任务执行时间相差太大,则没必要进行分解。我们可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。
-
优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高的任务先得到执行,需要注意的是如果一直有优先级高的任务提交到队列里,那么优先级低的任务可能永远不能执行。
-
执行时间不同的任务可以交给不同规模的线程池来处理,或者也可以使用优先级队列,让执行时间短的任务先执行。
依赖数据库连接池的任务,因为线程提交SQL后需要等待数据库返回结果,如果等待的时间越长CPU空闲时间就越长,那么线程数应该设置越大,这样才能更好的利用CPU。
并且,阻塞队列最好是使用有界队列,如果采用无界队列的话,一旦任务积压在阻塞队列中的话就会占用过多的内存资源,甚至会使得系统崩溃。
线程如何重用
原理分析
public void execute(Runnable command) {
//如果当前存在的线程少于corePoolSize,会新建线程来执行任务。然后各种检查状态
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);
}
接下来我们看看addWorker(runnable,core)方法。Worker是ThreadPoolExecutor的内部类,继承了AbstractQueuedSynchronizer,实现了Runnable接口。
private boolean addWorker(Runnable firstTask, boolean core) {
//...这里有一段cas代码,通过双重循环目的是通过cas增加线程池线程个数
//有兴趣的可以看看源码
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
//添加和扩容操作 ,这里加锁操作,是为了保证在添加操作的时候保证不会因多线程问题导致在添加到workers(HashSet)中出现异常
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
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);
}
return workerStarted;
}
这里的过程主要分成两步,第一步是一段 cas 代码通过双重循环检查状态并为当前线程数扩容 +1,第二部是将任务包装成 worker 对象,用线程安全的方式添加到当前工作 HashSet() 里,并开始执行线程。
接下来看一下worker中的run方法,其实就是调用了worker的runWorder()方法了。
public void run() {
runWorker(this);
}
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
可以看到这里判断了 firstTask 如果为空,就调用 getTask() 方法。getTask() 方法是从 workQueue 拉取任务。所以到这里之前的疑问就解决了,调用 addWorker(null,false) 的目的是启动一个线程,然后再 workQueue 拉取任务执行。继续 getTask() 方法:
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
终于看到从 workQueue 拉取元素了。 调用 workQueue.poll() 从队列拉取一个任务,等待 keepAliveTime, keepAliveTime后超时,线程就会会被回收。如果 keepAliveTime 内,进来一个任务,会发生什么情况?
任务在 execute() 方法里,会被 offer() 进 workQueue ,因为目前队列是空的,所以 offer 进来后,马上会被阻塞的 worker.poll() 拉取出来,然后在 runWorker() 方法里执行,因为线程没有新建所以达到了线程的复用。至此,我们已经明白了线程复用的秘密,以及线程保留 keepAliveTime 的实现方法。
复用原理主要参考以下链接。作者写的很好,相对自己还有很多地方需要学习
参考链接:https://mp.weixin.qq.com/s/jISHo8-aKMPjjeCYGJILgg