本文参考了http://www.th7.cn/Program/java/201309/148236.shtml
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲(如正在等待某个事件),则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。
java中的Executor框架就提供了4种线程池
先来看一张表
Executors的四种线程池
| 1.newCachedThreadPool() | -缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse.如果没有，就建一个新的线程加入池中 -缓存型池子通常用于执行一些生存期很短的异步型任务 -能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s,超过这个IDLE时长，线程实例将被终止及移出池。 |
| 2. newFixedThreadPool | -newFixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程 -其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子 -和cacheThreadPool不同，FixedThreadPool没有IDLE机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的），所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器 -从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同: fixed池线程数固定，并且是0秒IDLE（无IDLE） cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力），60秒IDLE |
| 3.ScheduledThreadPool | -调度型线程池 -这个池子里的线程可以按schedule依次delay执行，或周期执行 |
| 4.SingleThreadExecutor | -单例线程，任意时间池中只能有一个线程 -用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE） |
这里着重关注的是newCachedThreadPool和newFixedThreadPool这两个方法 单从方法上来看 newCachedThreadPool无需指定线程池的最大线程数，
但这种方法往往也会带来灾难性的毁灭。
下面是摘自stackoverflow论坛上的一段话
"Choosing the executor service for a particular application can be tricky. If you’re writing a small program, or a lightly loaded server, using Executors.new- CachedThreadPool is generally agood choice, as it demands no configuration and generally “does the right thing.” But a cached thread pool is not a good choice for a heavily loaded production server!
In a cached thread pool, submitted tasks are not queued but immediately handed off to a thread for execution. If no threads are available, a new one is created. If a server is so heavily loaded that all of its CPUs are fully utilized, and more tasks arrive, more threads will be created, which will only make matters worse.
Therefore, in a heavily loaded production server, you are much better off usingExecutors.newFixedThreadPool, which gives you a pool with a fixed number of threads, or using the ThreadPoolExecutor class directly, for maximum control."
大概意思是指newCachedThreadPool方法有可能会因为无法限制线程数目而导致无限制的增长线程，从而导致更大的问题出现。
我们不妨进入ThreadPoolExecutor源码看看，在进入源码之前
必须知道线程池的五个状态
RUNNING,SHUTDOWN,STOP,TIDYING,TERMINATED
java将状态值与工作线程数打包在一个整型中，用整形的上3位表示状态，下29位表示工作线程数，这个属性字段为"ctl",
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
“ctl状态”来描述当前线程池状态，用“ctl计数”来描述当前线程池工作线程计数
这里只贴出两者的最简构造函数，具体可进入源码查看
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
以及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;
}
可以看到 最明显的区别就是工作队列workQueue以及线程池的数目初始化发生了改变
线程池submit以后，很明显在execute()方法里进行了线程的工作
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
} 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) {
//调用workCountOf()方法获取当前线程池中线程数量，判断当前线程数量是否超过了核心线程数，若未超过，则直接添加一个核心线程，并用此线程完成当前提交的任务。newCachedThreadPool永远不会进入该if块 因为corePoolSize设置为0
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {//若当前线程数已经超过核心线程数且ctl状态等于RUNNING,则将该任务加入工作队列，等待空闲线程工作，若工作成功进入工作等待队列 如果是newCachedThreadPool则会搜索是否有空闲的线程，如果没有则跳过 ，如果是newFixedThreadPool线程池，提交工作队列的情况一般是工作线程已经大于了线程池最大线程数量。
（特别是通过newCachedThreadPool得到的线程池的workQueue的offer方法，涉及到SynchronousQueue这个类的transfer方法，很有研究意义，日后也会分析这个方法
int recheck = ctl.get();//进一步复查ctl
if (! isRunning(recheck) && remove(command))
//如果此时ctl已经不再RUNNING，则尝试移除该任务
reject(command);//调用拒绝工作任务方法
//（这里之所以需要复查ctl状态是由于在执行workQueue.offer(command)方法时，ctl状态随时可能由于调用shutDown方法或者shutDownNow方法而发生变化）。
else if (workerCountOf(recheck) == 0)//如果不满足if条件(即不在RUNNING状态或者移除任务失败并且工作线程为0
addWorker(null, false);
}
else if (!addWorker(command, false))//newCachedThreadPool得到的线程池任务会直接在这执行
reject(command);
}
//如果上述两种情况都不吻合，即此时已经有超过核心线程数的的线程在工作，且任务队列也已堆满，则尝试增加一个工作线程（如果此时线程数达到限定最大线程数，则会失败），若失败则调用拒绝任务方法reject(command).
在execute的方法中添加工作线程的所调用的法为addWorker(Runnable runnable,Boolean core).该方法接受两个参数，runnable对象为这个新建线程的第一个工作任务，可以为空。core指代新建的任务是否是核心线程。
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();//h获取工作线程计数
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))
//调用compareAndIncrementWorkerCount(c)尝试增加当前ctl计数，若成功则跳出外层循环。若失败则重复价检查当前线程池ctl状态(之所以检查ctl是因为造成失败的原因为ctl发生变化，这有两种可能，一种是作为下29位的工作线程计数发生变化，一种是作为上3位的状态标志位发生变化，这里检查的就是上3位的变化)，若是ctl状态发生变化，则重新尝试外层循环（这是有可能外层循环会由于ctl状态的变化而直接return false）。若是ctl计数发生变化，则重新尝试内层循环。
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
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();//获取主锁 保证对共享资源workers的排他访问
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;
}
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数组并且正式开始运转。
接下来我们看ThreadPoolExecutor的另一个核心方法runWork(Worker w)
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
//获取当前worker的第一个任务置于task变量中，之后执行w.firstTask = null。若不将worker对象的firstTask置为空，则firstTask引用指向的task对象将不会被gc回收
w.unlock(); // allow interrupts
//将worker对象解锁，从而允许其在尚未获得task之前被中断
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
//进入while循环，如果task为null了,这里将调用getTask()方法获取任务task对象（可能造成线程等待），若因为各种原因（下面说明getTask()方法时会说到）返回null（即获取不到任务）则停止while循环，将completedAbruptly置为false。
w.lock();
//进入循环内部，代表已经获取到可执行的task对象，则锁定worker对象（保证不被shutDown方法中断）
// 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();//执行目标任务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);
}
//接着做条件判断，若ctl状态超过STOP态，或者当前线程已经因为线程池内部状态变化而被中断（如何判断中断是因为线程池内部状态变化而中断的？重复检查ctl状态即可，若线程的中断信号是在外部逻辑代码中设置的（不使用线程池的shutDownNow方法，直接使用的thread.interrupt()方法），则ctl状态不会为STOP，这样就可判定为不是因为线程池内部状态变化而引起的中断），则设置该工作线程为中断状态（wt.interrupt()）。否则执行beforeExecute(wt,task)钩子方法，用户可以重写该方法而达到一些自定义需求（例如统计）。接着执行获得task的run方法，至此该worker成功获得并执行了一个任务。执行期间抛出的异常都有处理，不再多说。最终将置task为空，增加worker的完成任务数（completedTasks）,随后解锁worker。
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
//
processWorkerExit方法会处理处理统计信息，将worker的completedTask累加入线程池的completedTaskCount，并从线程池的workers中移除该worker,之后尝试终止线程池（因为这个worker可能是当前线程池中最后一个worker,tryTerminate方法应该在所有可能终止当前线程的地方被调用）。最后根据completedAbruptly的值选择策略，若为true，则直接调用addWorker增加一个新worker用以替代当前移除的worker；若为false则判断当前线程池大小是否小于允许的最小线程池大小（可能是corePoolSize也可能小于），若小于则调用addWorker增加一个新worker，否则什么也不做。已经工作完成的Thread会阻塞在runWork()函数的while()语句中，等待新的任务。
扫一扫
227
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
