java 线程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue
ThreadFactory threadFactory,
RejectedExecutionHandler handler);
一.参数1.核心线程数2.最大线程数3.空闲线程等待时间4等待的单位.5队列.6.创建线程的工厂7.拒绝任务策略
corePoolSize：线程池的基本大小，核心线程数，核心线程会一直存活，即使没有任务需要处理。当线程数小于核心线程数时，即使现有的线程空闲，线程池也会优先创建新线程来处理任务，而不是直接交给现有的线程处理。
maximumPoolSize：线程池最大大小，当线程数大于或等于核心线程，且任务队列已满时，线程池会创建新的线程，直到线程数量达到maxPoolSize。如果线程数已等于maxPoolSize，且任务队列已满，则已超出线程池的处理能力，线程池会拒绝处理任务而抛出异常。
workQueue：等待队列，当达到corePoolSize的时候，就向该等待队列放入线程信息（默认为一个LinkedBlockingQueue），运行中的队列属性为：workers。
keepAliveTime：默认都是0，当线程没有任务处理后，保持多长时间，cachedPoolSize是默认60s，不推荐使用。
threadFactory：是构造Thread的方法，你可以自己去包装和传递，主要实现newThread方法即可。
handler：也就是参数maximumPoolSize达到后丢弃处理的方法，java提供了5种丢弃处理的方法；java默认的是使用AbortPolicy，他的作用是当出现这中情况的时候会抛出一个异常。
二.提交任务的两种方法
threadPoolExecutor.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
});
Future
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return null;
}
});
2.ThreadPoolExecutor线程建立流程
线程池按以下行为执行任务：
（1）当线程数小于核心线程数时，创建线程。
（2）当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。
（3）当线程数大于等于核心线程数，且任务队列已满
- 若线程数小于最大线程数，创建线程
- 若线程数等于最大线程数，抛出异常，拒绝任务
3.ThreadPoolExecutor源码—execute()方法
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);
}
execute执行时：
1.调用workCountOf()方法获取当前线程池中线程数量，判断当前线程数量是否超过了核心线程数，若未超过，则直接添加一个核心线程，并用此线程完成当前提交的任务。
2.若当前线程数已经超过核心线程数且ctl状态等于RUNNING且工作成功进入工作等待队列，则我们进一步复查ctl，若ctl状态依旧为RUNNING，且调用workCountOf()方法检查发现此时的工作线程数为0时，将添加一个工作线程；若此时已经不为RUNNING，则尝试移除任务，并调用拒绝任务方法:reject(command)。（这里之所以需要复查ctl状态是由于在执行workQueue.offer(command)方法时，ctl状态随时可能由于调用shutDown方法或者shutDownNow方法而发生变化）。
3.如果上述两种情况都不吻合，即此时已经有超过核心线程数的的线程在工作，且任务队列也已堆满，则尝试增加一个工作线程（如果此时线程数达到限定最大线程数，则会失败），若失败则调用拒绝任务方法reject(command).
在execute的方法中添加工作线程的所调用的法为addWorker(Runnable runnable,Boolean core).该方法接受两个参数，runnable对象为这个新建线程的第一个工作任务，可以为空。core指代新建的任务是否是核心线程。
4.ThreadPoolExecutor源码— 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()))
return false;
表示ctl状态为RUNNING状态或者为SHUTDOWN状态且此时任务队列仍有任务未执行完时，可以继续调用addWorker添加工作线程，但不能新建任务，即firstTask参数必须为null.否则这里将返回false,即新建工作线程失败。
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
这部分对当前线程数量做了判断，依据core参数，若core参数为true，即添加的为核心线程，则当前工作的线程数量不应当超过corePoolSize，否则返回false。若core参数为false,即添加的为普通线程，则当前工作的线程数量不应当超过maximumPoolSize,否则返回false。通过上述校验，则调用compareAndIncrementWorkerCount(c)尝试增加当前ctl计数，若成功则跳出外曾循环。若失败则重复检查当前线程池ctl状态(之所以检查ctl是因为造成失败的原因为ctl发生变化，这有两种可能，一种是作为下29位的工作线程计数发生变化，一种是作为上3位的状态标志位发生变化，这里检查的就是上3位的变化)，若是ctl状态发生变化，则重新尝试外层循环（这是有可能外层循环会由于ctl状态的变化而直接return false）。若是ctl计数发生变化，则重新尝试内层循环。
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
final ReentrantLock mainLock = this.mainLock;
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int c = ctl.get();
int rs = runStateOf(c);
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;
}
这部分获取了线程池的主锁mainLock。从而保证对共享资源workers的排他访问。这里通过new Worker(firstTask) 新建了一个worker对象，该对象持有他的第一个任务firstTask。Woker类的构造方法，将通过ThreadFactory获取一个thread对象，这里可能失败，返回null,或者抛出异常。所以在上面的代码段中对这种情况作了处理，若返回null,则workerStarted将为false。将执行addWorkerFailed方法处理失败情况；若抛出异常同样workerStarted将为false。将同样执行addWorkerFailed方法。若成功通过ThreadFactory新建了一个持有当前worker对象的thread对象，则继续往下recheck ctl状态(规则与1没有区别)，通过校验则将当前worker放入workers数组中，然后重新校正队则池大小（largestPoolSize），置workerAdded标志位为true。最后通过wokerAdded标志位校验，置workerStarted标志位为true,启动线程，该线程持有当前worker对象，会执行worker对象的run方法，而woker对象的run方法又调用了自身的runWorker(this)方法。至此为止一个worker正式被添加进入workers数组并且正式开始运转。
5.ThreadPoolExecutor源码—runWorker()方法
| 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); } }
|
1.先说明一个变量completedAbruptly，这个布尔值被用于指代runWorker停止的原因，当completedAbruptly为true时代表worker停止是因为worker执行的外部业务逻辑代码抛出异常引起的。当completedAbruptly为false时代表worker停止是线程池内部工作机制下的正常退出。
2.获取当前执行线程，获取当前worker的第一个任务置于task变量中，之后执行w.firstTask = null。若不不将worker对象的firstTask置为空，则firstTask引用指向的task对象将不会被gc回收。将worker对象解锁，从而允许其在尚未获得task之前被中断。进入while循环，这里将调用getTask()方法获取任务task对象（可能造成线程等待），若因为各种原因（下面说明getTask()方法时会说到）返回null（即获取不到任务）则停止while循环，将completedAbruptly置为false。
3.进入循环内部，代表已经获取到可执行的task对象，则锁定worker对象（保证不被shutDown方法中断），接着做条件判断，若ctl状态超过STOP态，或者当前线程已经因为线程池内部状态变化而被中断（如何判断中断是因为线程池内部状态变化而中断的？重复检查ctl状态即可，若线程的中断信号是在外部逻辑代码中设置的（不使用线程池的shutDownNow方法，直接使用的thread.interrupt()方法），则ctl状态不会为STOP，这样就可判定为不是因为线程池内部状态变化而引起的中断），则设置该工作线程为中断状态（wt.interrupt()）。否则执行beforeExecute(wt,task)钩子方法，用户可以重写该方法而达到一些自定义需求（例如统计）。接着执行获得task的run方法，至此该worker成功获得并执行了一个任务。执行期间抛出的异常都有处理，不再多说。最终将置task为空，增加worker的完成任务数（completedTasks）,随后解锁worker。
4.在最外层的finally块中，执行了processWorkerExit(w,completedAbruptly)方法，该方法会处理处理统计信息，将worker的completedTask累加入线程池的completedTaskCount，并从线程池的workers中移除该worker,之后尝试终止线程池（因为这个worker可能是当前线程池中最后一个worker,tryTerminate方法应该在所有可能终止当前线程的地方被调用）。最后根据completedAbruptly的值选择策略，若为true，则直接调用addWorker增加一个新worker用以替代当前移除的worker；若为false则判断当前线程池大小是否小于允许的最小线程池大小（可能是corePoolSize也可能小于），若小于则调用addWorker增加一个新worker，否则什么也不做。
6.ThreadPoolExecutor源码—getTask()方法
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
retry:
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;
}
boolean timed; // Are workers subject to culling?
for (;;) {
int wc = workerCountOf(c);
timed = allowCoreThreadTimeOut || wc > corePoolSize;
if (wc <= maximumPoolSize && ! (timedOut && timed))
break;
if (compareAndDecrementWorkerCount(c))
return null;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
1.同样首先说明一个变量，timeOut，这个布尔值指代当前getTask方法是否超时未能获取到task对象。
2.外层for循环首先校验ctl状态，若ctl状态大于SHUTDOWN或者等于SHUTDOWN且任务队列workQueue为空，则返回null。否则进入内层循环，若当前线程数量小于maximumPoolSize且并未超时或者当前线程池不存在超时限制（由timed变量指代），则跳出循环，否则则尝试减小ctl计数，并返回null。若尝试减小ctl计数失败（由于ctl值变化引起，上面addWorker中第2点已经提到过），则先检查ctl状态，若失败是由ctl状态变化引起，则尝试外层循环，若失败是由于ctl计数变化而引起则尝试内层循环。
3.在第二点中，跳出循环之后，将根据timed的值做不同策略。若timed为true,即线程池存在超时限制，则执行workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS),这个方法将只在keepAliveTime时间内等待获取任务，一旦超过则返回null；若timed为false,则执行workQueue.take()方法，该方法将无限时等待任务，直至获取任务或者出现中断异常。在这两个方法之一返回之后，若返回task为null，则设置timeOut为true，尝试外层循环；若task不为null，则返回成功获取的task对象。
4.如果在getTask期间出现中断异常，则设置timeOut为false,并且重试外层循环，即InterruptedException并不会对getTask方法造成任何影响，真正能影响getTask方法的是ctl状态的转变。
7.ThreadPoolExecutor源码—shutdown()方法
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
调用shutdown()方法，将获得主锁mainLock，并且查看是否有执行shutdown的权限，然后调用advanceRunState方法，将ctl状态置为shutdown。调用interruptIdleWorkers()方法关闭尚未获得task对象的worker(即还未执行到getTask()方法或者还未得到getTask()返回的worker)。之后调用onShutdown()钩子方法，用户可以在这里处理自定义逻辑。最后调用tryTerminate()方法尝试终止线程池。
final void tryTerminate() {
for (;;) {
int c = ctl.get();
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
terminated();
} finally {
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
1.tryTerminate()方法尝试终止线程池活动，满足终止条件的因素有两个：首先，ctl状态为STOP,或者为SHUTDOWN且任务队列为空（STOP状态之所以一直都不用判断workQueue是因为上面讲到的，shutdownNow()方法调用了drainQueue()方法清空了workQueue所以其必然为空，这里解释一下）；其次，ctl计数为0。第二个条件的满足是由一连串连锁反应保证的，shutdownNow()方法置ctl状态为STOP,使得所有worker调用getTask()方法满足rs>=SHUTDOWN条件从而调用decrementWorkerCount()方法，这将最终导致ctl计数为0，同时所有work都将从getTask()方法获得null，最终导致runWorker()方法调用processWorkerExit（）方法，将workers数组真正清空。shutdown（）方法稍微复杂，它置ctl状态为SHUTDOWN，但是线程池仍将继续运行，直至所有workers将工作队列中的任务全部完成，之后的逻辑和stop状态下的完全一样，不再多说。
2.在保证了上述两个条件之后，tryTerminate()方法获取住所mainLock，置ctl状态为TIDYING,之后执行terminated钩子方法，最后置ctl状态为TERMINATED。