最近被问如何实现一个高效的java 线程池。其实在JDK1.5 以后,并发包里面已经提供了一个同步工具类Executors。里面可以直接取一些默认实现的线程池。
Executors里面提供出来的都是静态方法,调用如下:Executors.newFixedThreadPool(1).
几种常用的线程池如下:
FixedThreadPool: 创建一个固定线程数量的线程池。
CachedThreadPool:创建一个线程可重用的线程池,大小没限制。
SingleThreadExecutor:创建只有一个线程的线程池。
ScehduledThreadPool:创建一个定时执行的线程池
从代码里面可以看到,线程池的创建其实是生成一个ThreadPoolExecutor对象来实现线程池相关功能的。
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)
下面说说每个参数的意义:
corePoolSize:类似于一个最小线程数。池中至少要保持这么多线程数。
maximumPoolSize:最大线程数。
keepAliveTime:就是说如果池中当前有多于 corePoolSize 的线程,则这些多出的线程在空闲时间超过 keepAliveTime 时将会终止。
unit:时间单位,给上面一个参数用的。
workQueue:所有在等待的要执行任务都会被加入到这个队列。
threadFactory:线程工厂类,给工作线程做一层包装。
handler:当 Executor 已经关闭,并且 Executor 将有限边界用于最大线程和工作队列容量,且已经饱和时,提交的新提交的任务将被拒绝。
下面看execute方法。
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) {//运行的线程少于 corePoolSize,则创建新线程来处理请求
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {//<span style="font-family: Arial, Helvetica, sans-serif;">运行的线程大于 corePoolSize,放入等待队列</span>
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);
}
执行分3步:1. 如果运行的线程少于 corePoolSize,则创建新线程来处理请求。
2. 如果运行的线程多于 corePoolSize 而少于 maximumPoolSize,将任务放入等待队列。然后重新当前执行器状态和线程池,如果执行状态改变,则拒绝此任务。否则新开一个线程如果pool是空的。
3. 如果任务不能放入队列,则尝试新开一个执行线程。如果失败了,则拒绝此任务。
这里提到两个操作:addWorker和 reject 方法。
addWorker:把当前任务包装成内部类实现Worker,然后执行。Worker本身实现了Runnable接口,内部再持有一个Thread实例。Worker的run方法会循环抓取queue中的待执行任务,然后执行。而内部持有的Thread实例则用来响应线程池的中断和关闭的。
Reject是当线程池无法满足新的任务执行或关闭的时候,而采取的一个拒绝策略。
预定义的处理程序策略:
在默认的 ThreadPoolExecutor.AbortPolicy 中,处理程序遭到拒绝将抛出运行时 RejectedExecutionException。
在 ThreadPoolExecutor.CallerRunsPolicy 中,线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制,能够减缓新任务的提交速度。
在 ThreadPoolExecutor.DiscardPolicy 中,不能执行的任务将被删除。
在 ThreadPoolExecutor.DiscardOldestPolicy 中,如果执行程序尚未关闭,则位于工作队列头部的任务将被删除,然后重试执行程序(如果再次失败,则重复此过程)。
定义和使用其他种类的 RejectedExecutionHandler 类也是可能的,但这样做需要非常小心,尤其是当策略仅用于特定容量或排队策略时。
线程池关闭
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
未完待续。。