本文主要讲解java中线程池的。
前言
Executor框架是一个根据一组执行策略调用，调度，执行和控制的异步任务的框架，目的是提供一种将”任务提交”与”任务运行”分离开来的机制。
继承体系
- Executor
- void execute(Runnable command)。
- ExecutorService 接口在其父类接口基础上，
- void shutdown(); 启动有序关闭，在该关闭中将执行先前提交的*任务，但将不接受任何新任务。 , *如果调用已经关闭，则调用不会产生任何其他影响。
- List shutdownNow(); 尝试停止所有正在执行的任务，暂停正在等待的任务的处理，并返回正在等待执行的任务的列表。 , * *
此方法不等待正在执行的任务终止。, 使用{@link #awaitTermination awaitTermination}进行*。 , * *
除了尽力而为之外，不能保证停止处理正在执行的任务。, 例如，典型的*实现将通过{@link Thread＃interrupt}取消，因此任何无法响应中断的任务都可能永远不会终止。
- invokeAll、
- invokeAny 等方法。
- Future submit(Callable task); 提交一个执行返回值的任务，并返回一个* Future，表示任务的未决结果。 , * Future的{@code get}方法将在成功完成后返回任务的结果。 如果您想立即阻止等待某项任务，则可以使用* {@code result = exec.submit（aCallable）.get（）;}形式的构造
- Future<?> submit(Runnable task)；
- ScheduledExecutorService 接口，
- 则是声明了一些和定时任务相关的方法，比如 schedule和scheduleAtFixedRate。
- 线程池的核心实现是在 ThreadPoolExecutor 类中，
- 我们使用 Executors 调用newFixedThreadPool、newSingleThreadExecutor和newCachedThreadPool等方法创建线程池均是 ThreadPoolExecutor 类型。
核心参数
在说线程池原理或者机制之前，首先需要了解一下构建线程池过程中需要配置的那些参数。
- corePoolSize：核心线程数，cpu+1；表示核心线程池的大小。
- 当提交一个任务时，如果当前核心线程池的线程个数没有达到corePoolSize，则会创建新的线程来执行所提交的任务，即使当前核心线程池有空闲的线程。如果当前核心线程池的线程个数已经达到了corePoolSize，则不再重新创建线程。如果调用了prestartCoreThread()或者 prestartAllCoreThreads()，线程池创建的时候所有的核心线程都会被创建并且启动。
- maxPoolSize:最大线程数。
- 当线程池里面的线程数超过corePoolSize，小于maximumPoolSize时会动态创建与回收线程池里面的线程池资源。
- long keepAliveTime：空闲线程存活时间。表示线程没有执行任务时最多保持多久时间会终止。
- 默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会生效,直到线程池数量不大于corePoolSize，即只有当线程池数量大于corePoolSize数量，超出这个数量的线程一旦到达keepAliveTime就会终止。但是如果调用了allowCoreThreadTimeout(boolean)方法，即使线程池的线程数量不大于corePoolSize，线程也会在keepAliveTime之后就终止，知道线程池的数量为0为止。
- TimeUnit unit：参数keepAliveTime的时间单位，一个时间单位枚举类。
- BlockingQueue：一个阻塞队列，用来存储等待执行任务的队列。
- 这个参数选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列就是（ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue；用于保存任务的阻塞队列，关于阻塞队列可以看这篇文章。可以使用ArrayBlockingQueue, LinkedBlockingQueue, SynchronousQueue, PriorityBlockingQueue。
- RejectExecutionHandler：线程池的拒绝策略
- AbortPolicy：一言不合就抛异常（默认使用策略）。
- CallerRunsPolicy：只用调用者所在线程来运行任务。
- DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
- DiscardPolicy：不处理，直接丢弃。
流程图
资源回收
考虑到系统资源是有限的，对于线程池超出 corePoolSize 数量的空闲线程应进行回收操作。进行此操作存在一个问题，即回收时机。
目前的实现方式是当线程空闲时间超过 keepAliveTime 后，进行回收。除了核心线程数之外的线程可以进行回收，核心线程内的空闲线程也可以进行回收。回收的前提是allowCoreThreadTimeOut属性被设置为 true，
通过public void allowCoreThreadTimeOut(boolean)方法可以设置属性值。
优缺点
- 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
- 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
- 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
四种常见线程池
Java通过Executors提供四种线程池
- newCachedThreadPool：new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue()); 创建一个根据需要创建新线程的线程池，但将在以前构造的线程可用时重用它们。, 这些池通常会提高执行许多短期异步任务的程序的性能。 , 调用{@code execute}将重用以前构造的线程（如果可用）。, 如果没有可用的现有线程，则将创建一个新的线程并将其添加到池中。, 具有未使用60秒的线程将终止并从缓存中删除。, 因此，长时间闲置的池将不会消耗任何资源。, 请注意，可以使用{@link ThreadPoolExecutor}构造函数创建具有类似*属性但具有不同详细信息（例如，超时参数）*的池。
- newFixedThreadPool（num）：new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), threadFactory);创建一个线程池，该线程池重用固定数量的线程在共享的无界队列*中运行，使用提供的* ThreadFactory在需要时创建新线程。, 在任何时候，最多{@code nThreads}线程将是活动处理任务。, 如果在所有线程都处于活动状态时提交了其他任务，则它们将在队列中等待，直到线程可用。, 如果任何线程在关闭之前的执行期间由于故障而终止，则如果*需要执行后续任务，则新线程将取代它。, 池中的线程将存在，直到它显式{@link ExecutorService＃shutdown * shutdown}。
- newScheduledThreadPool：创建一个单线程执行程序，可以调度命令在给定延迟后运行，或定期执行。 , （但请注意，如果由于在关闭之前执行期间出现故障而导致此单个线程终止，则在执行后续任务时，如果需要执行后续任务，则将使用新的。）任务保证按顺序执行*，并且不超过, 一个任务将在任何给定时间激活。, 与其他等效的 {@code newScheduledThreadPool（1）}不同，返回的执行程序*保证不可重新配置以使用其他线程。 , * @return新创建的预定执行人。支持定时及周期性任务执行。
- newSingleThreadExecutor：new ThreadPoolExecutor(1, 1, 0L,TimeUnit.MILLISECONDS, new LinkedBlockingQueue())创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
线程池的关闭
- 关闭线程池，可以通过shutdown和shutdownNow这两个方法。它们的原理都是遍历线程池中所有的线程，然后依次中断线程。shutdown和shutdownNow还是有不一样的地方：
- shutdownNow首先将线程池的状态设置为STOP,然后尝试停止所有的正在执行和未执行任务的线程，并返回等待执行任务的列表；
- shutdown只是将线程池的状态设置为SHUTDOWN状态，然后中断所有没有正在执行任务的线程
如何合理配置线程池参数？
任务性质不同的任务可以用不同规模的线程池分开处理。
-
CPU密集型任务配置尽可能少的线程数量，如配置Ncpu+1个线程的线程池。
-
IO密集型任务则由于需要等待IO操作，线程并不是一直在执行任务，则配置尽可能多的线程，如2xNcpu。
-
混合型的任务，如果可以拆分，则将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐率要高于串行执行的吞吐率，如果这两个任务执行时间相差太大，则没必要进行分解。我们可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。
-
优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高的任务先得到执行，需要注意的是如果一直有优先级高的任务提交到队列里，那么优先级低的任务可能永远不能执行。
-
执行时间不同的任务可以交给不同规模的线程池来处理，或者也可以使用优先级队列，让执行时间短的任务先执行。
依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，如果等待的时间越长CPU空闲时间就越长，那么线程数应该设置越大，这样才能更好的利用CPU。
并且，阻塞队列最好是使用有界队列，如果采用无界队列的话，一旦任务积压在阻塞队列中的话就会占用过多的内存资源，甚至会使得系统崩溃。
线程如何重用
原理分析
public void execute(Runnable command) {
//如果当前存在的线程少于corePoolSize，会新建线程来执行任务。然后各种检查状态
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);
}
接下来我们看看addWorker(runnable,core)方法。Worker是ThreadPoolExecutor的内部类，继承了AbstractQueuedSynchronizer，实现了Runnable接口。
private boolean addWorker(Runnable firstTask, boolean core) {
//...这里有一段cas代码，通过双重循环目的是通过cas增加线程池线程个数
//有兴趣的可以看看源码
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
//添加和扩容操作 ，这里加锁操作，是为了保证在添加操作的时候保证不会因多线程问题导致在添加到workers（HashSet）中出现异常
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;
}
这里的过程主要分成两步，第一步是一段 cas 代码通过双重循环检查状态并为当前线程数扩容 +1，第二部是将任务包装成 worker 对象，用线程安全的方式添加到当前工作 HashSet() 里，并开始执行线程。
接下来看一下worker中的run方法，其实就是调用了worker的runWorder（）方法了。
public void run() {
runWorker(this);
}
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);
}
}
可以看到这里判断了 firstTask 如果为空，就调用 getTask() 方法。getTask() 方法是从 workQueue 拉取任务。所以到这里之前的疑问就解决了，调用 addWorker(null,false) 的目的是启动一个线程，然后再 workQueue 拉取任务执行。继续 getTask() 方法：
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;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
终于看到从 workQueue 拉取元素了。 调用 workQueue.poll() 从队列拉取一个任务，等待 keepAliveTime， keepAliveTime后超时,线程就会会被回收。如果 keepAliveTime 内，进来一个任务，会发生什么情况?
任务在 execute() 方法里，会被 offer() 进 workQueue ，因为目前队列是空的，所以 offer 进来后，马上会被阻塞的 worker.poll() 拉取出来，然后在 runWorker() 方法里执行，因为线程没有新建所以达到了线程的复用。至此，我们已经明白了线程复用的秘密，以及线程保留 keepAliveTime 的实现方法。
复用原理主要参考以下链接。作者写的很好，相对自己还有很多地方需要学习
参考链接：https://mp.weixin.qq.com/s/jISHo8-aKMPjjeCYGJILgg
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
