一、总览
线程池类ThreadPoolExecutor的相关类需要先了解:
(图片来自:https://javadoop.com/post/java-thread-pool#%E6%80%BB%E8%A7%88)
Executor:位于最顶层,只有一个 execute(Runnable runnable) 方法,用于提交任务。
ExecutorService :在 Executor 接口的基础上添加了很多的接口方法,提交任务,获取结果,关闭线程池。
AbstractExecutorService:实现了ExecutorService 接口,然后在其基础上实现了几个实用的方法,这些方法提供给子类进行调用。
ThreadPoolExecutor:线程池类
Executors:最常用的用于生成 ThreadPoolExecutor 的实例的工具类
FutureTask:Runnable, Future -> RunnableFuture -> FutureTask
FutureTask 通过 RunnableFuture 间接实现了 Runnable 接口, 所以每个 Runnable 通常都先包装成 FutureTask, 然后调用 executor.execute(Runnable command) 将其提交给线程池
Runnable 的 void run() 方法是没有返回值的,如果我们需要的话,会在 submit 中指定第二个参数作为返回值。
Callable:Callable 也是因为线程池的需要,所以才有了这个接口。它和 Runnable 的区别在于 run() 没有返回值,而 Callable 的 call() 方法有返回值
BlockingQueue:Java并发(十八):阻塞队列BlockingQueue
二、线程池状态
线程池中的各个状态:
- RUNNING:这个没什么好说的,这是最正常的状态:接受新的任务,处理等待队列中的任务
- SHUTDOWN:不接受新的任务提交,但是会继续处理等待队列中的任务
- STOP:不接受新的任务提交,不再处理等待队列中的任务,中断正在执行任务的线程
- TIDYING:所有的任务都销毁了,workCount 为 0。线程池的状态在转换为 TIDYING 状态时,会执行钩子方法 terminated()
- TERMINATED:terminated() 方法结束后,线程池的状态就会变成这个
状态转换:
- RUNNING -> SHUTDOWN:当调用了 shutdown() 后,会发生这个状态转换,这也是最重要的
- (RUNNING or SHUTDOWN) -> STOP:当调用 shutdownNow() 后,会发生这个状态转换,这下要清楚 shutDown() 和 shutDownNow() 的区别了
- SHUTDOWN -> TIDYING:当任务队列和线程池都清空后,会由 SHUTDOWN 转换为 TIDYING
- STOP -> TIDYING:当任务队列清空后,发生这个转换
- TIDYING -> TERMINATED:这个前面说了,当 terminated() 方法结束后
ThreadPoolExecutor采用一个 32 位的整数来存放线程池的状态和当前池中的线程数,其中高 3 位用于存放线程池状态,低 29 位表示线程数。
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); // 这里 COUNT_BITS 设置为 29(32-3),意味着前三位用于存放线程状态,后29位用于存放线程数 // 很多初学者很喜欢在自己的代码中写很多 29 这种数字,或者某个特殊的字符串,然后分布在各个地方,这是非常糟糕的 private static final int COUNT_BITS = Integer.SIZE - 3; // 000 11111111111111111111111111111 // 这里得到的是 29 个 1,也就是说线程池的最大线程数是 2^29-1=536870911 // 以我们现在计算机的实际情况,这个数量还是够用的 private static final int CAPACITY = (1 << COUNT_BITS) - 1; // 我们说了,线程池的状态存放在高 3 位中 // 运算结果为 111跟29个0:111 00000000000000000000000000000 private static final int RUNNING = -1 << COUNT_BITS; // 000 00000000000000000000000000000 private static final int SHUTDOWN = 0 << COUNT_BITS; // 001 00000000000000000000000000000 private static final int STOP = 1 << COUNT_BITS; // 010 00000000000000000000000000000 private static final int TIDYING = 2 << COUNT_BITS; // 011 00000000000000000000000000000 private static final int TERMINATED = 3 << COUNT_BITS; // 将整数 c 的低 29 位修改为 0,就得到了线程池的状态 private static int runStateOf(int c) { return c & ~CAPACITY; } // 将整数 c 的高 3 为修改为 0,就得到了线程池中的线程数 private static int workerCountOf(int c) { return c & CAPACITY; } private static int ctlOf(int rs, int wc) { return rs | wc; } private static boolean runStateLessThan(int c, int s) { return c < s; } private static boolean runStateAtLeast(int c, int s) { return c >= s; } private static boolean isRunning(int c) { return c < SHUTDOWN; }
三、线程池参数
通过ThreadPoolExecutor构造函数来看线程池参数:
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0) throw new IllegalArgumentException(); if (workQueue == null || threadFactory == null || handler == null) throw new NullPointerException(); this.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; }
corePoolSize:线程池中核心线程的数量。当提交一个任务时,线程池会新建一个线程来执行任务,直到当前线程数等于corePoolSize。如果调用了线程池的prestartAllCoreThreads()方法,线程池会提前创建并启动所有基本线程。
maximumPoolSize:线程池中允许的最大线程数。线程池的阻塞队列满了之后,如果还有任务提交,如果当前的线程数小于maximumPoolSize,则会新建线程来执行任务。注意,如果使用的是无界队列,该参数也就没有什么效果了。
keepAliveTime:空闲线程的保活时间,如果某线程的空闲时间超过这个值都没有任务给它做,那么可以被关闭了。注意这个值并不会对所有线程起作用,如果线程池中的线程数少于等于核心线程数 corePoolSize,那么这些线程不会因为空闲太长时间而被关闭,当然,也可以通过调用 allowCoreThreadTimeOut(true)
使核心线程数内的线程也可以被回收
unit:keepAliveTime的单位。TimeUnit
workQueue:
用来保存等待执行的任务的阻塞队列,等待的任务必须实现Runnable接口。我们可以选择如下几种:
- ArrayBlockingQueue:基于数组结构的有界阻塞队列,FIFO。
- LinkedBlockingQueue:基于链表结构的有界阻塞队列,FIFO。
- SynchronousQueue:不存储元素的阻塞队列,每个插入操作都必须等待一个移出操作,反之亦然。
threadFactory:用于设置创建线程的工厂。
handler:
RejectedExecutionHandler,线程池的拒绝策略。
所谓拒绝策略,是指将任务添加到线程池中时,线程池拒绝该任务所采取的相应策略。当向线程池中提交任务时,如果此时线程池中的线程已经饱和了,而且阻塞队列也已经满了,则线程池会选择一种拒绝策略来处理该任务。
线程池提供了四种拒绝策略:(重写RejectedExecutionHandler.rejectedExecution(Runnable, ThreadPoolExecutor))
AbortPolicy:直接抛出异常,默认策略;
CallerRunsPolicy:用调用者所在的线程来执行任务;
DiscardOldestPolicy:丢弃阻塞队列中靠最前的任务,并执行当前任务;
DiscardPolicy:直接丢弃任务;
当然我们也可以实现自己的拒绝策略,例如记录日志等等,实现RejectedExecutionHandler接口写rejectedExecution方法即可。
四、线程池创建
Executor工具类提供了三种线程池创建方式:
FixedThreadPool :可重用固定线程数的线程池
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }
corePoolSize 和 maximumPoolSize都设置为创建FixedThreadPool时指定的参数nThreads,意味着当线程池满时且阻塞队列也已经满时,如果继续提交任务,则会直接走拒绝策略,该线程池不会再新建线程来执行任务,而是直接走拒绝策略。FixedThreadPool使用的是默认的拒绝策略,即AbortPolicy,则直接抛出异常。
keepAliveTime设置为0L,表示空闲的线程会立刻终止。
workQueue则是使用LinkedBlockingQueue,但是没有设置范围,那么则是最大值(Integer.MAX_VALUE),这基本就相当于一个无界队列了。使用该“无界队列”则会带来哪些影响呢?当线程池中的线程数量等于corePoolSize 时,如果继续提交任务,该任务会被添加到阻塞队列workQueue中,当阻塞队列也满了之后,则线程池会新建线程执行任务直到maximumPoolSize。由于FixedThreadPool使用的是“无界队列”LinkedBlockingQueue,那么maximumPoolSize参数无效,同时指定的拒绝策略AbortPolicy也将无效。而且该线程池也不会拒绝提交的任务,如果客户端提交任务的速度快于任务的执行,那么keepAliveTime也是一个无效参数。
SingleThreadExecutor:只有一个线程的固定线程池
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); }
为单一worker线程的线程池,SingleThreadExecutor把corePool和maximumPoolSize均被设置为1,和FixedThreadPool一样使用的是无界队列LinkedBlockingQueue,所以带来的影响和FixedThreadPool一样。
CachedThreadPool:根据需要创建新线程的线程池
public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); }
CachedThreadPool的corePool为0,maximumPoolSize为Integer.MAX_VALUE,这就意味着所有的任务一提交就会加入到阻塞队列中。
keepAliveTime这是为60L,unit设置为TimeUnit.SECONDS,意味着空闲线程等待新任务的最长时间为60秒,空闲线程超过60秒后将会被终止。
阻塞队列采用的SynchronousQueue,SynchronousQueue是一个没有元素的阻塞队列,加上corePool = 0 ,maximumPoolSize = Integer.MAX_VALUE,这样就会存在一个问题,如果主线程提交任务的速度远远大于CachedThreadPool的处理速度,则CachedThreadPool会不断地创建新线程来执行任务,这样有可能会导致系统耗尽CPU和内存资源,所以在使用该线程池是,一定要注意控制并发的任务数,否则创建大量的线程可能导致严重的性能问题。
五、执行过程
execute()方法执行任务:
(1)execute(Runnable command):
workerCount < corePoolSize:addWorker(command, true)
workerCount > corePoolSize && 任务可放入阻塞队列:addWorker(null, false);
workerCount > BlockingQueue.size:addWorker(command, false),如果失败拒绝策略
(2)addWorker(Runnable firstTask, boolean core):new一个worker线程来执行任务
ctl + 1
workers.add(worker);
worker.start();
(3)worker.run()-runWorker(Worker w):
Runnable task = w.firstTask;
while(task != null || (task = getTask()) != null) {
task.run();
}
执行任务的run()方法
执行完一个任务后,在阻塞队列中取任务继续执行
(4)getTask():workQueue.take();阻塞队列中取任务
提交任务:
线程池根据业务不同的需求提供了两种方式提交任务:Executor.execute()、ExecutorService.submit()。其中ExecutorService.submit()可以获取该任务执行的Future。
execute()
执行流程如下:
(1)如果线程池当前线程数小于corePoolSize,则调用addWorker创建新线程执行任务,成功返回true,失败执行步骤2。
(2)如果线程池处于RUNNING状态,则尝试加入阻塞队列,如果加入阻塞队列成功,则尝试进行Double Check,如果加入失败,则执行步骤3。
如果加入阻塞队列成功了,则会进行一个Double Check的过程。Double Check过程的主要目的是判断加入到阻塞队里中的线程是否可以被执行。如果线程池不是RUNNING状态,则调用remove()方法从阻塞队列中删除该任务,然后调用reject()方法处理任务。否则需要确保还有线程执行。
(3)如果线程池不是RUNNING状态或者加入阻塞队列失败,则尝试创建新线程直到maxPoolSize,如果失败,则调用reject()方法运行相应的拒绝策略。
public void execute(Runnable command) { if (command == null) throw new NullPointerException(); // 前面说的那个表示 “线程池状态” 和 “线程数” 的整数 int c = ctl.get(); // 如果当前线程数少于核心线程数,那么直接添加一个 worker 来执行任务, // 创建一个新的线程,并把当前任务 command 作为这个线程的第一个任务(firstTask) if (workerCountOf(c) < corePoolSize) { // 添加任务成功,那么就结束了。提交任务嘛,线程池已经接受了这个任务,这个方法也就可以返回了 // 至于执行的结果,到时候会包装到 FutureTask 中。 // 返回 false 代表线程池不允许提交任务 if (addWorker(command, true)) return; c = ctl.get(); } // 到这里说明,要么当前线程数大于等于核心线程数,要么刚刚 addWorker 失败了 // 如果线程池处于 RUNNING 状态,把这个任务添加到任务队列 workQueue 中 if (isRunning(c) && workQueue.offer(command)) { /* 这里面说的是,如果任务进入了 workQueue,我们是否需要开启新的线程 * 因为线程数在 [0, corePoolSize) 是无条件开启新的线程 * 如果线程数已经大于等于 corePoolSize,那么将任务添加到队列中,然后进到这里 */ int recheck = ctl.get(); // 如果线程池已不处于 RUNNING 状态,那么移除已经入队的这个任务,并且执行拒绝策略 if (! isRunning(recheck) && remove(command)) reject(command); // 如果线程池还是 RUNNING 的,并且线程数为 0,那么开启新的线程 // 到这里,我们知道了,这块代码的真正意图是:担心任务提交到队列中了,但是线程都关闭了 else if (workerCountOf(recheck) == 0) addWorker(null, false); } // 如果 workQueue 队列满了,那么进入到这个分支 // 以 maximumPoolSize 为界创建新的 worker, // 如果失败,说明当前线程数已经达到 maximumPoolSize,执行拒绝策略 else if (!addWorker(command, false)) reject(command); }
addWorker
在这里需要好好理论addWorker中的参数,在execute()方法中,有三处调用了该方法:
第一次:workerCountOf(c) < corePoolSize ==> addWorker(command, true),这个很好理解,当然线程池的线程数量小于 corePoolSize ,则新建线程执行任务即可,在执行过程core == true,内部与corePoolSize比较即可。
第二次:加入阻塞队列进行Double Check时,else if (workerCountOf(recheck) == 0) ==>addWorker(null, false)。如果线程池中的线程==0,按照道理应该该任务应该新建线程执行任务,但是由于已经该任务已经添加到了阻塞队列,那么就在线程池中新建一个空线程,然后从阻塞队列中取线程即可。
第三次:线程池不是RUNNING状态或者加入阻塞队列失败:else if (!addWorker(command, false)),这里core == fase,则意味着是与maximumPoolSize比较。
执行流程:
(1)判断当前线程是否可以添加任务,如果可以则进行下一步,否则return false;
- rs >= SHUTDOWN ,表示当前线程处于SHUTDOWN ,STOP、TIDYING、TERMINATED状态
- rs == SHUTDOWN , firstTask != null时不允许添加线程,因为线程处于SHUTDOWN 状态,不允许添加任务
- rs == SHUTDOWN , firstTask == null,但workQueue.isEmpty() == true,不允许添加线程,因为firstTask == null是为了添加一个没有任务的线程然后再从workQueue中获取任务的,如果workQueue == null,则说明添加的任务没有任何意义。
(2)内嵌循环,通过CAS worker + 1
(3)获取主锁mailLock,如果线程池处于RUNNING状态获取处于SHUTDOWN状态且 firstTask == null,则将任务添加到workers Queue中,然后释放主锁mainLock,然后启动线程,然后return true,如果中途失败导致workerStarted= false,则调用addWorkerFailed()方法进行处理。
// 第一个参数是准备提交给这个线程执行的任务,之前说了,可以为 null // 第二个参数为 true 代表使用核心线程数 corePoolSize 作为创建线程的界线,也就说创建这个线程的时候, // 如果线程池中的线程总数已经达到 corePoolSize,那么不能响应这次创建线程的请求 // 如果是 false,代表使用最大线程数 maximumPoolSize 作为界线 private boolean addWorker(Runnable firstTask, boolean core) { retry: for (;;) { int c = ctl.get(); int rs = runStateOf(c); // 这个非常不好理解 // 如果线程池已关闭,并满足以下条件之一,那么不创建新的 worker: // 1. 线程池状态大于 SHUTDOWN,其实也就是 STOP, TIDYING, 或 TERMINATED // 2. firstTask != null // 3. workQueue.isEmpty() // 简单分析下: // 还是状态控制的问题,当线程池处于 SHUTDOWN 的时候,不允许提交任务,但是已有的任务继续执行 // 当状态大于 SHUTDOWN 时,不允许提交任务,且中断正在执行的任务 // 多说一句:如果线程池处于 SHUTDOWN,但是 firstTask 为 null,且 workQueue 非空,那么是允许创建 worker 的 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; // 由于有并发,重新再读取一下 ctl c = ctl.get(); // 正常如果是 CAS 失败的话,进到下一个里层的for循环就可以了 // 可是如果是因为其他线程的操作,导致线程池的状态发生了变更,如有其他线程关闭了这个线程池 // 那么需要回到外层的for循环 if (runStateOf(c) != rs) continue retry; // else CAS failed due to workerCount change; retry inner loop } } /* * 到这里,我们认为在当前这个时刻,可以开始创建线程来执行任务了, * 因为该校验的都校验了,至于以后会发生什么,那是以后的事,至少当前是满足条件的 */ // worker 是否已经启动 boolean workerStarted = false; // 是否已将这个 worker 添加到 workers 这个 HashSet 中 boolean workerAdded = false; Worker w = null; try { final ReentrantLock mainLock = this.mainLock; // 把 firstTask 传给 worker 的构造方法 w = new Worker(firstTask); // 取 worker 中的线程对象,之前说了,Worker的构造方法会调用 ThreadFactory 来创建一个新的线程 final Thread t = w.thread; if (t != null) { // 这个是整个类的全局锁,持有这个锁才能让下面的操作“顺理成章”, // 因为关闭一个线程池需要这个锁,至少我持有锁的期间,线程池不会被关闭 mainLock.lock(); try { int c = ctl.get(); int rs = runStateOf(c); // 小于 SHUTTDOWN 那就是 RUNNING,这个自不必说,是最正常的情况 // 如果等于 SHUTDOWN,前面说了,不接受新的任务,但是会继续执行等待队列中的任务 if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { // worker 里面的 thread 可不能是已经启动的 if (t.isAlive()) throw new IllegalThreadStateException(); // 加到 workers 这个 HashSet 中 workers.add(w); int s = workers.size(); // largestPoolSize 用于记录 workers 中的个数的最大值 // 因为 workers 是不断增加减少的,通过这个值可以知道线程池的大小曾经达到的最大值 if (s > largestPoolSize) largestPoolSize = s; workerAdded = true; } } finally { mainLock.unlock(); } // 添加成功的话,启动这个线程 if (workerAdded) { // 启动线程 t.start(); workerStarted = true; } } } finally { // 如果线程没有启动,需要做一些清理工作,如前面 workCount 加了 1,将其减掉 if (! workerStarted) addWorkerFailed(w); } // 返回线程是否启动成功 return workerStarted;
Woker内部类
从Worker的源码中我们可以看到Woker继承AQS,实现Runnable接口,所以可以认为Worker既是一个可以执行的任务,也可以达到获取锁释放锁的效果。这里继承AQS主要是为了方便线程的中断处理。这里注意两个地方:构造函数、run()。构造函数主要是做三件事:1.设置同步状态state为-1,同步状态大于0表示就已经获取了锁,2.设置将当前任务task设置为firstTask,3.利用Worker本身对象this和ThreadFactory创建线程对象。
private final class Worker extends AbstractQueuedSynchronizer implements Runnable { private static final long serialVersionUID = 6138294804551838833L; // task 的thread final Thread thread; // 运行的任务task Runnable firstTask; volatile long completedTasks; Worker(Runnable firstTask) { //设置AQS的同步状态private volatile int state,是一个计数器,大于0代表锁已经被获取 setState(-1); this.firstTask = firstTask; // 利用ThreadFactory和 Worker这个Runnable创建的线程对象 this.thread = getThreadFactory().newThread(this); } // 任务执行 public void run() { runWorker(this); } }
runWorker
运行流程:
(1)根据worker获取要执行的任务task,然后调用unlock()方法释放锁,这里释放锁的主要目的在于中断,因为在new Worker时,设置的state为-1,调用unlock()方法可以将state设置为0,这里主要原因就在于interruptWorkers()方法只有在state >= 0时才会执行;
(2)通过getTask()获取执行的任务,调用task.run()执行,当然在执行之前会调用worker.lock()上锁,执行之后调用worker.unlock()放锁;
(3)在任务执行前后,可以根据业务场景自定义beforeExecute() 和 afterExecute()方法,则两个方法在ThreadPoolExecutor中是空实现;
(4)如果线程执行完成,则会调用getTask()方法从阻塞队列中获取新任务,如果阻塞队列为空,则根据是否超时来判断是否需要阻塞;
(5)task == null或者抛出异常(beforeExecute()、task.run()、afterExecute()均有可能)导致worker线程终止,则调用processWorkerExit()方法处理worker退出流程。
// 此方法由 worker 线程启动后调用,这里用一个 while 循环来不断地从等待队列中获取任务并执行 // 前面说了,worker 在初始化的时候,可以指定 firstTask,那么第一个任务也就可以不需要从队列中获取 final void runWorker(Worker w) { // Thread wt = Thread.currentThread(); // 该线程的第一个任务(如果有的话) Runnable task = w.firstTask; w.firstTask = null; w.unlock(); // allow interrupts boolean completedAbruptly = true; try { // 循环调用 getTask 获取任务 while (task != null || (task = getTask()) != null) { w.lock(); // 如果线程池状态大于等于 STOP,那么意味着该线程也要中断 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) { // 这里不允许抛出 Throwable,所以转换为 Error thrown = x; throw new Error(x); } finally { // 也是一个钩子方法,将 task 和异常作为参数,留给需要的子类实现 afterExecute(task, thrown); } } finally { // 置空 task,准备 getTask 获取下一个任务 task = null; // 累加完成的任务数 w.completedTasks++; // 释放掉 worker 的独占锁 w.unlock(); } } completedAbruptly = false; } finally { // 如果到这里,需要执行线程关闭: // 1. 说明 getTask 返回 null,也就是说,这个 worker 的使命结束了,执行关闭 // 2. 任务执行过程中发生了异常 // 第一种情况,已经在代码处理了将 workCount 减 1,这个在 getTask 方法分析中会说 // 第二种情况,workCount 没有进行处理,所以需要在 processWorkerExit 中处理 // 限于篇幅,我不准备分析这个方法了,感兴趣的读者请自行分析源码 processWorkerExit(w, completedAbruptly); } }
getTask()
// 此方法有三种可能: // 1. 阻塞直到获取到任务返回。我们知道,默认 corePoolSize 之内的线程是不会被回收的, // 它们会一直等待任务 // 2. 超时退出。keepAliveTime 起作用的时候,也就是如果这么多时间内都没有任务,那么应该执行关闭 // 3. 如果发生了以下条件,此方法必须返回 null: // - 池中有大于 maximumPoolSize 个 workers 存在(通过调用 setMaximumPoolSize 进行设置) // - 线程池处于 SHUTDOWN,而且 workQueue 是空的,前面说了,这种不再接受新的任务 // - 线程池处于 STOP,不仅不接受新的线程,连 workQueue 中的线程也不再执行 private Runnable getTask() { boolean timedOut = false; // Did the last poll() time out? retry: for (;;) { int c = ctl.get(); int rs = runStateOf(c); // 两种可能 // 1. rs == SHUTDOWN && workQueue.isEmpty() // 2. rs >= STOP if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) { // CAS 操作,减少工作线程数 decrementWorkerCount(); return null; } boolean timed; // Are workers subject to culling? for (;;) { int wc = workerCountOf(c); // 允许核心线程数内的线程回收,或当前线程数超过了核心线程数,那么有可能发生超时关闭 timed = allowCoreThreadTimeOut || wc > corePoolSize; // 这里 break,是为了不往下执行后一个 if (compareAndDecrementWorkerCount(c)) // 两个 if 一起看:如果当前线程数 wc > maximumPoolSize,或者超时,都返回 null // 那这里的问题来了,wc > maximumPoolSize 的情况,为什么要返回 null? // 换句话说,返回 null 意味着关闭线程。 // 那是因为有可能开发者调用了 setMaximumPoolSize 将线程池的 maximumPoolSize 调小了 if (wc <= maximumPoolSize && ! (timedOut && timed)) break; if (compareAndDecrementWorkerCount(c)) return null; c = ctl.get(); // Re-read ctl // compareAndDecrementWorkerCount(c) 失败,线程池中的线程数发生了改变 if (runStateOf(c) != rs) continue retry; // else CAS failed due to workerCount change; retry inner loop } // wc <= maximumPoolSize 同时没有超时 try { // 到 workQueue 中获取任务 Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { // 如果此 worker 发生了中断,采取的方案是重试 // 解释下为什么会发生中断,这个读者要去看 setMaximumPoolSize 方法, // 如果开发者将 maximumPoolSize 调小了,导致其小于当前的 workers 数量, // 那么意味着超出的部分线程要被关闭。重新进入 for 循环,自然会有部分线程会返回 null timedOut = false; } } }
processWorkerExit()
在runWorker()方法中,无论最终结果如何,都会执行processWorkerExit()方法对worker进行退出处理。
首先completedAbruptly的值来判断是否需要对线程数-1处理,如果completedAbruptly == true,说明在任务运行过程中出现了异常,那么需要进行减1处理,否则不需要,因为减1处理在getTask()方法中处理了。然后从HashSet中移出该worker,过程需要获取mainlock。然后调用tryTerminate()方法处理,该方法是对最后一个线程退出做终止线程池动作。如果线程池没有终止,那么线程池需要保持一定数量的线程,则通过addWorker(null,false)新增一个空的线程。
private void processWorkerExit(Worker w, boolean completedAbruptly) { // true:用户线程运行异常,需要扣减 // false:getTask方法中扣减线程数量 if (completedAbruptly) decrementWorkerCount(); // 获取主锁 final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { completedTaskCount += w.completedTasks; // 从HashSet中移出worker workers.remove(w); } finally { mainLock.unlock(); } // 有worker线程移除,可能是最后一个线程退出需要尝试终止线程池 tryTerminate(); int c = ctl.get(); // 如果线程为running或shutdown状态,即tryTerminate()没有成功终止线程池,则判断是否有必要一个worker if (runStateLessThan(c, STOP)) { // 正常退出,计算min:需要维护的最小线程数量 if (!completedAbruptly) { // allowCoreThreadTimeOut 默认false:是否需要维持核心线程的数量 int min = allowCoreThreadTimeOut ? 0 : corePoolSize; // 如果min ==0 或者workerQueue为空,min = 1 if (min == 0 && ! workQueue.isEmpty()) min = 1; // 如果线程数量大于最少数量min,直接返回,不需要新增线程 if (workerCountOf(c) >= min) return; // replacement not needed } // 添加一个没有firstTask的worker addWorker(null, false); } }
六、关闭线程池
tryTerminate()
当线程池涉及到要移除worker时候都会调用tryTerminate(),该方法主要用于判断线程池中的线程是否已经全部移除了,如果是的话则关闭线程池。
final void tryTerminate() { for (;;) { int c = ctl.get(); // 线程池处于Running状态 // 线程池已经终止了 // 线程池处于ShutDown状态,但是阻塞队列不为空 if (isRunning(c) || runStateAtLeast(c, TIDYING) || (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty())) return; // 执行到这里,就意味着线程池要么处于STOP状态,要么处于SHUTDOWN且阻塞队列为空 // 这时如果线程池中还存在线程,则会尝试中断线程 if (workerCountOf(c) != 0) { // /线程池还有线程,但是队列没有任务了,需要中断唤醒等待任务的线程 // (runwoker的时候首先就通过w.unlock设置线程可中断,getTask最后面的catch处理中断) interruptIdleWorkers(ONLY_ONE); return; } final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { // 尝试终止线程池 if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) { try { terminated(); } finally { // 线程池状态转为TERMINATED ctl.set(ctlOf(TERMINATED, 0)); termination.signalAll(); } return; } } finally { mainLock.unlock(); } } }
线程池ThreadPoolExecutor提供了shutdown()和shutDownNow()用于关闭线程池。
shutdown():按过去执行已提交任务的顺序发起一个有序的关闭,但是不接受新任务。
public void shutdown() { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { checkShutdownAccess(); // 推进线程状态 advanceRunState(SHUTDOWN); // 中断空闲的线程 interruptIdleWorkers(); // 交给子类实现 onShutdown(); } finally { mainLock.unlock(); } tryTerminate(); }
shutdownNow() :尝试停止所有的活动执行任务、暂停等待任务的处理,并返回等待执行的任务列表。
shutdownNow会调用interruptWorkers()方法中断所有线程,同时会调用drainQueue()方法返回等待执行到任务列表。
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; }
private void interruptWorkers() { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { for (Worker w : workers) w.interruptIfStarted(); } finally { mainLock.unlock(); } }
private List<Runnable> drainQueue() { BlockingQueue<Runnable> q = workQueue; ArrayList<Runnable> taskList = new ArrayList<Runnable>(); q.drainTo(taskList); if (!q.isEmpty()) { for (Runnable r : q.toArray(new Runnable[0])) { if (q.remove(r)) taskList.add(r); } } return taskList; }
七、其他问题
1、任务拒绝策略
execute()方法中addWorker()失败会调用reject(command) 来处理任务
线程池此时不能接受这个任务,所以需要执行拒绝策略
此处的 handler 我们需要在构造线程池的时候就传入这个参数,它是 RejectedExecutionHandler 的实例。
RejectedExecutionHandler 在 ThreadPoolExecutor 中有四个已经定义好的实现类可供我们直接使用,当然,我们也可以实现自己的策略,不过一般也没有必要。
final void reject(Runnable command) { // 执行拒绝策略 handler.rejectedExecution(command, this); } // 只要线程池没有被关闭,那么由提交任务的线程自己来执行这个任务。 public static class CallerRunsPolicy implements RejectedExecutionHandler { public CallerRunsPolicy() { } public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) { r.run(); } } } // 不管怎样,直接抛出 RejectedExecutionException 异常 // 这个是默认的策略,如果我们构造线程池的时候不传相应的 handler 的话,那就会指定使用这个 public static class AbortPolicy implements RejectedExecutionHandler { public AbortPolicy() { } public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString()); } } // 不做任何处理,直接忽略掉这个任务 public static class DiscardPolicy implements RejectedExecutionHandler { public DiscardPolicy() { } public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { } } // 这个相对霸道一点,如果线程池没有被关闭的话, // 把队列队头的任务(也就是等待了最长时间的)直接扔掉,然后提交这个任务到等待队列中 public static class DiscardOldestPolicy implements RejectedExecutionHandler { public DiscardOldestPolicy() { } public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) { e.getQueue().poll(); e.execute(r); } } }
2、线程池中的线程初始化
默认情况下,创建线程池之后,线程池中是没有线程的,需要提交任务之后才会创建线程。
在实际中如果需要线程池创建之后立即创建线程,可以通过以下两个方法办到:
prestartCoreThread():初始化一个核心线程;
prestartAllCoreThreads():初始化所有核心线程
3、任务缓存队列及排队策略
workQueue的类型为BlockingQueue<Runnable>,通常可以取下面三种类型:
(1)ArrayBlockingQueue:基于数组的先进先出队列,此队列创建时必须指定大小;
(2)LinkedBlockingQueue:基于链表的先进先出队列,如果创建时没有指定此队列大小,则默认为Integer.MAX_VALUE;
(3)synchronousQueue:这个队列比较特殊,它不会保存提交的任务,而是将直接新建一个线程来执行新来的任务。
更多BlockingQueue参考 Java并发(十八):阻塞队列BlockingQueue
4、线程池容量的动态调整
ThreadPoolExecutor提供了动态调整线程池容量大小的方法:setCorePoolSize()和setMaximumPoolSize(),
setCorePoolSize:设置核心池大小
setMaximumPoolSize:设置线程池最大能创建的线程数目大小
当上述参数从小变大时,ThreadPoolExecutor进行线程赋值,还可能立即创建新的线程来执行任务。
5、线程池的监控
(1)通过线程池提供的参数进行监控。
taskCount:线程池需要执行的任务数量。
completedTaskCount:线程池在运行过程中已完成的任务数量。小于或等于taskCount。
largestPoolSize:线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小,则表示线程池曾经满了。
getPoolSize:线程池的线程数量。如果线程池不销毁的话,池里的线程不会自动销毁,所以这个大小只增不减。
getActiveCount:获取活动的线程数。
(2)通过扩展线程池进行监控。
通过继承线程池并重写线程池的beforeExecute,afterExecute和terminated方法,我们可以在任务执行前,执行后和线程池关闭前干一些事情。如监控任务的平均执行时间,最大执行时间和最小执行时间等。这几个方法在线程池里是空方法
八、线程池使用示例
为什么使用线程池?
1、降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
2、提高响应速度。当任务到达时,任务可以不需要的等到线程创建就能立即执行。
3、提高线程的可管理性。线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。但是要做到合理的利用线程池,必须对其原理了如指掌。
示例一:
class Test { public static void main(String[] args) { ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5)); for (int i = 0; i < 15; i++) { MyTask myTask = new MyTask(i); executor.execute(myTask); System.out.println("线程池中线程数目:" + executor.getPoolSize() + ",队列中等待执行的任务数目:" + executor.getQueue().size() + ",已执行玩别的任务数目:" + executor.getCompletedTaskCount()); } executor.shutdown(); } } class MyTask implements Runnable { private int taskNum; public MyTask(int num) { this.taskNum = num; } @Override public void run() { System.out.println("正在执行task " + taskNum); try { Thread.currentThread().sleep(4000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("task " + taskNum + "执行完毕"); } }
执行结果:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
正在执行task 0
线程池中线程数目:1,队列中等待执行的任务数目:0,已执行玩别的任务数目:0
线程池中线程数目:2,队列中等待执行的任务数目:0,已执行玩别的任务数目:0
正在执行task 1
正在执行task 2
线程池中线程数目:3,队列中等待执行的任务数目:0,已执行玩别的任务数目:0
线程池中线程数目:4,队列中等待执行的任务数目:0,已执行玩别的任务数目:0
正在执行task 3
线程池中线程数目:5,队列中等待执行的任务数目:0,已执行玩别的任务数目:0
正在执行task 4
线程池中线程数目:5,队列中等待执行的任务数目:1,已执行玩别的任务数目:0
线程池中线程数目:5,队列中等待执行的任务数目:2,已执行玩别的任务数目:0
线程池中线程数目:5,队列中等待执行的任务数目:3,已执行玩别的任务数目:0
线程池中线程数目:5,队列中等待执行的任务数目:4,已执行玩别的任务数目:0
线程池中线程数目:5,队列中等待执行的任务数目:5,已执行玩别的任务数目:0
线程池中线程数目:6,队列中等待执行的任务数目:5,已执行玩别的任务数目:0
正在执行task 10
线程池中线程数目:7,队列中等待执行的任务数目:5,已执行玩别的任务数目:0
正在执行task 11
线程池中线程数目:8,队列中等待执行的任务数目:5,已执行玩别的任务数目:0
正在执行task 12
线程池中线程数目:9,队列中等待执行的任务数目:5,已执行玩别的任务数目:0
正在执行task 13
线程池中线程数目:10,队列中等待执行的任务数目:5,已执行玩别的任务数目:0
正在执行task 14
task 0执行完毕
正在执行task 5
task 1执行完毕
task 2执行完毕
task 3执行完毕
task 4执行完毕
正在执行task 9
正在执行task 8
正在执行task 7
正在执行task 6
task 12执行完毕
task 13执行完毕
task 10执行完毕
task 11执行完毕
task 14执行完毕
task 5执行完毕
task 6执行完毕
task 7执行完毕
task 9执行完毕
task 8执行完毕
示例二:
需求:从数据库中获取url,并利用httpclient循环访问url地址,并对返回结果进行操作
分析:由于是循环的对多个url进行访问并获取数据,为了执行的效率,考虑使用多线程,url数量未知如果每个任务都创建一个线程将消耗大量的系统资源,最后决定使用线程池。
class GetMonitorDataService { private Logger logger = LoggerFactory.getLogger(GetMonitorDataService.class); @Resource private MonitorProjectUrlMapper groupUrlMapper; @Resource private MonitorDetailBatchInsertMapper monitorDetailBatchInsertMapper; public void sendData(){ //调用dao查询所有url MonitorProjectUrlExample example=new MonitorProjectUrlExample(); List<MonitorProjectUrl> list=groupUrlMapper.selectByExample(example); logger.info("此次查询数据库中监控url个数为"+list.size()); //获取系统处理器个数,作为线程池数量 int nThreads=Runtime.getRuntime().availableProcessors(); //定义一个装载多线程返回值的集合 List<MonitorDetail> result= Collections.synchronizedList(new ArrayList<MonitorDetail>()); //创建线程池,这里定义了一个创建线程池的工具类,避免了创建多个线程池,ThreadPoolFactoryUtil可以使用单例模式设计 ExecutorService executorService = ThreadPoolFactoryUtil.getExecutorService(nThreads); //遍历数据库取出的url if(list!=null&&list.size()>0) { for (MonitorProjectUrl monitorProjectUrl : list) { String url = monitorProjectUrl.getMonitorUrl(); //创建任务 ThreadTask threadTask = new ThreadTask(url, result); //执行任务 executorService.execute(threadTask); try {//等待直到所有任务完成 executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.MINUTES); } catch (InterruptedException e) { e.printStackTrace(); } } executorService.shutdown(); //对数据进行操作 saveData(result); } } } public class ThreadTask implements Runnable{ //这里实现runnable接口 private String url; private List<MonitorDetail> list; public ThreadTask(String url,List<MonitorDetail> list){ this.url=url; this.list=list; } //把获取的数据进行处理 @Override public void run() { MonitorDetail detail = HttpClientUtil.send(url, MonitorDetail.class); list.add(detail); } }
示例三:
public class FatureTest { //1、配置线程池 private static ExecutorService es = Executors.newFixedThreadPool(20); //2、封装响应Feature class BizResult{ public String orderId; public String data; public String getOrderId() { return orderId; } public void setOrderId(String orderId) { this.orderId = orderId; } public String getData() { return data; } public void setData(String data) { this.data = data; } } //3、实现Callable接口 class BizTask implements Callable { private String orderId; private Object data; //可以用其他方式 private CountDownLatch countDownLatch; public BizTask(String orderId, Object data, CountDownLatch countDownLatch) { this.orderId = orderId; this.data = data; this.countDownLatch = countDownLatch; } @Override public Object call() { try { //todo business System.out.println("当前线程Id = " + this.orderId); BizResult br = new BizResult(); br.setOrderId(this.orderId); br.setData("some key about your business" + this.getClass()); return br; }catch (Exception e){ e.printStackTrace(); }finally { //线程结束时,将计时器减一 countDownLatch.countDown(); } return null; } } /** * 业务逻辑入口 */ public List<Future> beginBusiness() throws InterruptedException { //模拟批量业务数据 List<String> list = new ArrayList<>(); for (int i = 0 ; i < 1000 ; i++) { list.add(String.valueOf(i)); } //设置计数器 CountDownLatch countDownLatch = new CountDownLatch(list.size()); //接收多线程响应结果 List<Future> resultList = new ArrayList<>(); //begin thread for( int i = 0 ,size = list.size() ; i<size; i++){ //todo something befor thread resultList.add(es.submit(new BizTask(list.get(i), null, countDownLatch))); } //wait finish countDownLatch.await(); return resultList; } public static void main(String[] args) throws InterruptedException { FatureTest ft = new FatureTest(); List<Future> futures = ft.beginBusiness(); System.out.println("futures.size() = " + futures.size()); //todo some operate System.out.println(" ==========================end========================= " ); } }
参考资料 / 相关推荐:
【死磕Java并发】—–J.U.C之线程池:ThreadPoolExecutor