Java线程池执行器ThreadPoolExecutor工作原理
来源:互联网 发布:盘古网络招聘 编辑:程序博客网 时间:2024/05/27 06:55
JDK版本:1.7.0_45。本文尝试分析ThreadPoolExecutor的构造方法的参数的作用,然后再分析主要逻辑。
一、构造方法及其参数
ThreadPoolExecutor位于java.util.concurrent包,有4个带参数的构造方法。最终被调用的构造方法如下。其他构造方法只是提供了默认的ThreadFactory或者RejectedExecutionHandler作为参数。
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
构造方法参数解析:
1. int corePoolSize
此参数字面上的意思是核心线程的数量。在public void execute(Runnable command)方法中,有以下几行代码:
if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return;}其中workerCountOf(c)方法返回的是当前正在运行的线程数,addWorker(command,true)方法的功能则是启动一个新的线程以执行command。
可见,当有新任务来到,当前运行的线程数少于corePoolSize的时候,ThreadPoolExecutor二话不说就启动一个新的线程来执行这个任务。
2.int maximumPoolSize
最大可运行的线程数量。 在addWorker方法中:
private boolean addWorker(Runnable firstTask, boolean core) {... int wc = workerCountOf(c); if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false; ......}addWorker的功能是创建新的线程并执行。
从上面的代码可见,当当前运行的线程数量大于等于maximumPoolSize时,ThreadPoolExecutor将不会再创建新的线程。
3.long keepAliveTime
private Runnable getTask() { boolean timedOut = false; // Did the last poll() time out? for (;;) { ... int wc = workerCountOf(c); boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; ... Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); ... } }线程池中的线程运行完上一个任务之后,将会通过getTask方法获取下一个任务来执行。即从构造方法中的BlockingQueue<Runnable> workQueue参数--阻塞队列中获取。
从上面的代码中可知,当timed为true的时候,keepAliveTime才起作用。而timed在两种情况下才为true:1.当前运行的线程数量大于核心线程的数量。2.allowCoreThreadTimeOut为true(此变量可通过public void allowCoreThreadTimeOut(boolean value)方法设置),即设置核心线程也受等待时长限制。
所以keepAliveTime的作用是,当前线程执行完这个任务之后,等待下一个任务到来的最长等待时间。如果在这个时间内没有新的任务来到,那当前线程就会退出。前提是满足两个上面说的两个条件。
4.其他参数
TimeUnit unit : keepAliveTime的时间单位。详见TimeUnit类说明。
BlockingQueue<Runnable> workQueue : 阻塞队列,用于存放待执行的任务。ThreadFactory threadFactory : 为Runnable任务创建线程的接口,实现可参照ThreadPoolExecutor的内部类DefaultThreadFactory。
RejectedExecutionHandler handler : java.util.concurrent包下的回调接口,当用户传入的任务无法被接收时,此接口的rejectedExecution方法会被调用。
二、主要方法及逻辑
ThreadPoolExecutor的主要逻辑写在public void execute(Runnable command)方法中:
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(); } 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); }
private static int workerCountOf(int c) { return c & CAPACITY; }
private static final int COUNT_BITS = Integer.SIZE - 3;private static final int CAPACITY = (1 << COUNT_BITS) - 1;
所以整数c的后28位存放着当前运行线程的数量?要验证这个问题,我们先看看c是从哪里来的:int c = ctl.get(); ,那ctl又是什么?
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));原来ctl是一个提供原子级操作的整数,关于AtomicInteger大家可以百度下,此处我们就当它是一个整数。其初始值为ctlOf(RUNNINT,0),这个又是什么方法?
private static int ctlOf(int rs, int wc) { return rs | wc; }
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;
看到这里就明了了,原来整数c的前4位存放ThreadPoolExecutor的运行状态,后28位存放运行线程的数量。那为什么要把这两个数打包到一起呢?这个问题我们后面再看。
所以当workerCountOf(c) < corePoolSize时,我们会进入到addWorker方法:
private boolean addWorker(Runnable firstTask, boolean core) { retry: for (;;) { int c = ctl.get();//当前运行线程的数量 int rs = runStateOf(c);//当前运行状态 // Check if queue empty only if necessary. if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) //当前的运行状态不为RUNNING,或者在SHUTDOWN状态下(不接受新任务但是会执行完队列中的任务),否则返回false return false; for (;;) { int wc = workerCountOf(c);//再检查一遍当前运行的线程数 if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))//线程的数量不能大于最大容量。如果该任务标记为核心任务,那线程的数量不能大于corePoolSize,不然的话不能大于maximunPoolSize,否则返回false return false; if (compareAndIncrementWorkerCount(c))//将线程数量加1,如果增加成功,则退出循环,执行后面的代码。失败一般都是因为线程数不同步。 break retry; c = ctl.get(); // Re-read ctl if (runStateOf(c) != rs)//再检查一遍运行状态,如果运行状态改变了,将从外循环开头开始执行,再次确认能否添加任务。 continue retry; // else CAS failed due to workerCount change; retry inner loop<pre name="code" class="java">//如果程序运行到这里,是因为线程数加1失败但是运行状态没有发生改变,此时会再执行内循环验证线程数。} } //下面的代码功能是创建新的Worker实例 boolean workerStarted = false;//线程是否启动 boolean workerAdded = false;//Worker是否已添加到Set中 Worker w = null; try { w = new Worker(firstTask); final Thread t = w.thread;//Worker实例中存放了一个Thread if (t != null) { 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; }
看来addWorker方法的大致功能就是创建一个新Worker实例,并执行Worker实例中的线程。
所以如果addWorker执行成功,则execute方法将直接返回。
如果addWorker执行失败,即不能为该任务创建一个新的线程。那么execute方法将尝试把这个方法放到阻塞队列中。即workQueue.offer(command)。如果offer成功,将再次检查运行状态和当前运行的线程数量,保证这两个值没有在offer期间发生改变。如果当前状态不是RUNNING,将拒绝这个任务。如果当前运行的线程数量为0,则执行addWorker(null, false);。这又是什么意思?为什么参数是null?
我们回到addWorker方法看一下。在创建Worker方法的时候,并没有判断Runnable是否为null。那它是怎么执行的?我们再看看Woker类
Worker(Runnable firstTask) { setState(-1); // inhibit interrupts until runWorker this.firstTask = firstTask; this.thread = getThreadFactory().newThread(this); }
/** Delegates main run loop to outer runWorker. */ public void run() { runWorker(this); }
final void runWorker(Worker w) { Thread wt = Thread.currentThread(); Runnable task = w.firstTask;//Worker构造方法中的参数在这里 w.firstTask = null; w.unlock(); // allow interrupts boolean completedAbruptly = true; try { while (task != null || (task = getTask()) != null) {//当task为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();//执行任务 } ... finally { afterExecute(task, thrown); } } finally { task = null; w.completedTasks++; w.unlock(); } } completedAbruptly = false; } finally { processWorkerExit(w, completedAbruptly); } }
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;//这里返回阻塞队列的Runnable。此处逻辑在前面的keepAliveTime中已讲过。 timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } }
到这里就明白了。当当前运行的线程数为0时,调用addWorker(null,false)时,将创建一个新的线程去取阻塞队列中的任务来执行。
最后,execute方法中,如果调用offer在阻塞队列存入任务失败,将调用addWorker(command, false)尝试启动一个非核心线程来执行任务。如果启动失败,此任务将被拒绝。
3.总结
所以,ThreadPoolExecutor的主要逻辑是,当用户调用execute(Runnable command) ,大致逻辑如下(注意是大致逻辑,代码中的逻辑更复杂更详细):
1.查看当前运行状态,如果不是RUNNING状态,将直接拒绝新任务。否则进入步骤2。
2.查看当前运行线程的数量,如果数量少于核心线程数,将直接创建新的线程执行该任务。否则进入步骤3。
3.将该任务添加到阻塞队列,等待核心线程执行完上一个任务再来获取。如果添加到阻塞队列失败,进入步骤4。
4.尝试创建一个非核心线程执行该任务,前提是线程的数量少于等于最大线程数。如果失败,拒绝该任务。
所以使用ThreadPoolExecutor需要注意下面几点:
1.allowCoreThreadTimeOut默认为false,如果不设置为true,那已被创建的少于等于核心线程数量的线程,将一直存在,处于运行状态或者阻塞在workQueue.take()中。
2.当前运行的线程数等于核心线程数了,任务才会被加入队列,当队列满了,才会创建非核心线程。所以如果使用LinkedBlockingQueue,那么队列将不会满,非核心线程不会被创建。
3.如果队列满了,当前运行的线程数也达到最大线程数了,那么新增的任务将被拒绝,即使并没有发生任何错误。所以应该做好被拒绝任务的处理工作。
小小程序猿一枚,才疏学浅,如果文章有不当的地方,望指正!
1 0
- Java线程池执行器ThreadPoolExecutor工作原理
- java线程池ThreadPoolExecutor原理及使用
- Java线程池ThreadPoolExecutor的execute()原理
- Java中线程池ThreadPoolExecutor原理探究
- 线程池ThreadPoolExecutor执行流程
- Java 线程池ThreadPoolExecutor
- Java 线程池ThreadPoolExecutor
- Java 线程池ThreadPoolExecutor
- JAVA线程池:ThreadPoolExecutor
- JAVA线程池ThreadPoolExecutor
- JAVA线程池ThreadPoolExecutor
- ThreadPoolExecutor java 线程池
- Java 线程池ThreadPoolExecutor
- java 线程池ThreadPoolExecutor
- JAVA线程池ThreadPoolExecutor
- java线程池:ThreadPoolExecutor
- Java线程池ThreadPoolExecutor
- Java 线程池 ThreadPoolExecutor
- logback logback.xml常用配置详解(二)<appender>
- C++中堆和栈
- hdu 3308 LCIS
- PowerDesign15.1导出sql
- 文件操作工具类-FileOptUtil
- Java线程池执行器ThreadPoolExecutor工作原理
- 20步打造最安全的Nginx Web服务器
- mac上调整phpstorm和webstorm的使用内存(默认是128m-750m) 避免卡顿
- memcached全面剖析--4. memcached的分布式算法
- Eclipse调试真机时LogCat的显示问题
- oracle误删数据表还原的二种方法(oracle还原)
- EditPlus配置java编辑环境
- ExpandableListView的使用详解
- getColor方法在6.0中已经过时